Merge pull request #1079 from home-assistant/dev

Release 163

.dockerignore

@@ -7,3 +7,7 @@
 
 # Temporary files
 **/__pycache__
+
+# virtualenv
+venv/
+ENV/

.github/ISSUE_TEMPLATE.md

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

.github/release-drafter.yml

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

.github/stale.yml

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

.gitignore

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

.gitmodules

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

.hadolint.yaml

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

.travis.yml

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

API.md

@@ -1,4 +1,4 @@
-# Hass.io Server
+# Hass.io
 
 ## Hass.io RESTful API
 
@@ -22,11 +22,14 @@ On success / Code 200:
 }
 ```
 
-For access to API you need set the `X-HASSIO-KEY` they will be available for Add-ons/HomeAssistant with envoriment `HASSIO_TOKEN`.
+For access to API you need set the `X-HASSIO-KEY` they will be available for Add-ons/HomeAssistant with environment `HASSIO_TOKEN`.
 
 ### Hass.io
 
 - GET `/supervisor/ping`
+
+This API call don't need a token.
+
 - GET `/supervisor/info`
 
 The addons from `addons` are only installed one.
@@ -38,7 +41,11 @@ The addons from `addons` are only installed one.
     "arch": "armhf|aarch64|i386|amd64",
     "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",
@@ -75,6 +82,9 @@ Optional:
     "channel": "stable|beta|dev",
     "timezone": "TIMEZONE",
     "wait_boot": "int",
+    "debug": "bool",
+    "debug_block": "bool",
+    "logging": "debug|info|warning|error|critical",
     "addons_repositories": [
         "REPO_URL"
     ]
@@ -273,7 +283,9 @@ return:
 ```json
 {
     "version": "2.3",
+    "version_cli": "7",
     "version_latest": "2.4",
+    "version_cli_latest": "8",
     "board": "ova|rpi"
 }
 ```
@@ -285,6 +297,13 @@ return:
 }
 ```
 
+- POST `/hassos/update/cli`
+```json
+{
+    "version": "optional"
+}
+```
+
 - POST `/hassos/config/sync`
 
 Load host configs from a USB stick.
@@ -302,9 +321,10 @@ Load host configs from a USB stick.
         "CARD_ID": {
             "name": "xy",
             "type": "microphone",
-            "devices": {
-                "DEV_ID": "type of device"
-            }
+            "devices": [
+                "chan_id": "channel ID",
+                "chan_type": "type of device"
+            ]
         }
     }
 }
@@ -333,14 +353,16 @@ Load host configs from a USB stick.
 {
     "version": "INSTALL_VERSION",
     "last_version": "LAST_VERSION",
+    "arch": "arch",
     "machine": "Image machine type",
+    "ip_address": "ip address",
     "image": "str",
     "custom": "bool -> if custom image",
     "boot": "bool",
     "port": 8123,
     "ssl": "bool",
     "watchdog": "bool",
-    "startup_time": 600
+    "wait_boot": 600
 }
 ```
 
@@ -362,6 +384,7 @@ Output is the raw Docker log.
 - POST `/homeassistant/check`
 - POST `/homeassistant/start`
 - POST `/homeassistant/stop`
+- POST `/homeassistant/rebuild`
 
 - POST `/homeassistant/options`
 
@@ -372,8 +395,9 @@ Output is the raw Docker log.
     "port": "port for access hass",
     "ssl": "bool",
     "password": "",
+    "refresh_token": "",
     "watchdog": "bool",
-    "startup_time": 600
+    "wait_boot": 600
 }
 ```
 
@@ -402,6 +426,8 @@ Proxy to real websocket instance.
 
 ### RESTful for API addons
 
+If an add-on will call itself, you can use `/addons/self/...`.
+
 - GET `/addons`
 
 Get all available addons.
@@ -413,11 +439,11 @@ Get all available addons.
             "name": "xy bla",
             "slug": "xy",
             "description": "description",
-            "arch": ["armhf", "aarch64", "i386", "amd64"],
             "repository": "core|local|REP_ID",
             "version": "LAST_VERSION",
             "installed": "none|INSTALL_VERSION",
             "detached": "bool",
+            "available": "bool",
             "build": "bool",
             "url": "null|url",
             "icon": "bool",
@@ -448,6 +474,10 @@ Get all available addons.
     "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",
@@ -456,7 +486,9 @@ Get all available addons.
     "build": "bool",
     "options": "{}",
     "network": "{}|null",
+    "network_description": "{}|null",
     "host_network": "bool",
+    "host_pid": "bool",
     "host_ipc": "bool",
     "host_dbus": "bool",
     "privileged": ["NET_ADMIN", "SYS_ADMIN"],
@@ -467,16 +499,29 @@ Get all available addons.
     "logo": "bool",
     "changelog": "bool",
     "hassio_api": "bool",
+    "hassio_role": "default|homeassistant|manager|admin",
     "homeassistant_api": "bool",
+    "auth_api": "bool",
+    "full_access": "bool",
+    "protected": "bool",
+    "rating": "1-6",
     "stdin": "bool",
     "webui": "null|http(s)://[HOST]:port/xy/zx",
     "gpio": "bool",
+    "kernel_modules": "bool",
     "devicetree": "bool",
+    "docker_api": "bool",
     "audio": "bool",
     "audio_input": "null|0,0",
     "audio_output": "null|0,0",
-    "services": "null|['mqtt']",
-    "discovery": "null|['component/platform']"
+    "services_role": "['service:access']",
+    "discovery": "['service']",
+    "ip_address": "ip address",
+    "ingress": "bool",
+    "ingress_entry": "null|/api/hassio_ingress/slug",
+    "ingress_url": "null|/api/hassio_ingress/slug/entry.html",
+    "ingress_port": "null|int",
+    "ingress_panel": "null|bool"
 }
 ```
 
@@ -497,12 +542,23 @@ Get all available addons.
     },
     "options": {},
     "audio_output": "null|0,0",
-    "audio_input": "null|0,0"
+    "audio_input": "null|0,0",
+    "ingress_panel": "bool"
 }
 ```
 
 Reset custom network/audio/options, set it `null`.
 
+- POST `/addons/{addon}/security`
+
+This function is not callable by itself.
+
+```json
+{
+    "protected": "bool",
+}
+```
+
 - POST `/addons/{addon}/start`
 
 - POST `/addons/{addon}/stop`
@@ -540,39 +596,70 @@ Write data to add-on stdin
 }
 ```
 
-### Service discovery
+### ingress
 
-- GET `/services/discovery`
+- POST `/ingress/session`
+
+Create a new Session for access to ingress service.
+
+```json
+{
+    "session": "token"
+}
+```
+
+- GET `/ingress/panels`
+
+Return a list of enabled panels.
+
+```json
+{
+    "panels": {
+        "addon_slug": {
+            "enable": "boolean",
+            "icon": "mdi:...",
+            "title": "title",
+            "admin": "boolean"
+        }
+    }
+}
+```
+
+- VIEW `/ingress/{token}`
+
+Ingress WebUI for this Add-on. The addon need support HASS Auth!
+Need ingress session as cookie.
+
+### discovery
+
+- GET `/discovery`
 ```json
 {
     "discovery": [
         {
-            "provider": "name",
+            "addon": "slug",
+            "service": "name",
             "uuid": "uuid",
-            "component": "component",
-            "platform": "null|platform",
             "config": {}
         }
     ]
 }
 ```
 
-- GET `/services/discovery/{UUID}`
+- GET `/discovery/{UUID}`
 ```json
 {
-    "provider": "name",
+    "addon": "slug",
+    "service": "name",
     "uuid": "uuid",
-    "component": "component",
-    "platform": "null|platform",
     "config": {}
 }
 ```
 
-- POST `/services/discovery`
+- POST `/discovery`
 ```json
 {
-    "component": "component",
-    "platform": "null|platform",
+    "service": "name",
     "config": {}
 }
 ```
@@ -584,7 +671,9 @@ return:
 }
 ```
 
-- DEL `/services/discovery/{UUID}`
+- DEL `/discovery/{UUID}`
+
+### Services
 
 - GET `/services`
 ```json
@@ -593,7 +682,7 @@ return:
         {
             "slug": "name",
             "available": "bool",
-            "provider": "null|name|list"
+            "providers": "list"
         }
     ]
 }
@@ -601,12 +690,10 @@ return:
 
 #### MQTT
 
-This service performs an auto discovery to Home-Assistant.
-
 - GET `/services/mqtt`
 ```json
 {
-    "provider": "name",
+    "addon": "name",
     "host": "xy",
     "port": "8883",
     "ssl": "bool",
@@ -629,3 +716,32 @@ This service performs an auto discovery to Home-Assistant.
 ```
 
 - 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"
+}
+```
+
+### Auth / SSO API
+
+You can use the user system on homeassistant. We handle this auth system on
+supervisor.
+
+You can call post `/auth`
+
+We support:
+- Json `{ "user|name": "...", "password": "..." }`
+- application/x-www-form-urlencoded `user|name=...&password=...`
+- BasicAuth

Dockerfile

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

README.md

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

azure-pipelines.yml

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

hassio/__init__.py

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

hassio/__main__.py

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

hassio/addons/__init__.py

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

hassio/addons/build.py

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

hassio/addons/data.py

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

hassio/addons/model.py

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

hassio/addons/utils.py

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

hassio/addons/validate.py

@@ -1,32 +1,104 @@
-"""Validate addons options schema."""
+"""Validate add-ons options schema."""
 import logging
 import re
+import secrets
 import uuid
 
 import voluptuous as vol
 
 from ..const import (
-    ATTR_NAME, ATTR_VERSION, ATTR_SLUG, ATTR_DESCRIPTON, ATTR_STARTUP,
-    ATTR_BOOT, ATTR_MAP, ATTR_OPTIONS, ATTR_PORTS, STARTUP_ONCE,
-    STARTUP_SYSTEM, STARTUP_SERVICES, STARTUP_APPLICATION, STARTUP_INITIALIZE,
-    BOOT_AUTO, BOOT_MANUAL, ATTR_SCHEMA, ATTR_IMAGE, ATTR_URL, ATTR_MAINTAINER,
-    ATTR_ARCH, ATTR_DEVICES, ATTR_ENVIRONMENT, ATTR_HOST_NETWORK, ARCH_ARMHF,
-    ARCH_AARCH64, ARCH_AMD64, ARCH_I386, ATTR_TMPFS, ATTR_PRIVILEGED,
-    ATTR_USER, ATTR_STATE, ATTR_SYSTEM, STATE_STARTED, STATE_STOPPED,
-    ATTR_LOCATON, ATTR_REPOSITORY, ATTR_TIMEOUT, ATTR_NETWORK, ATTR_UUID,
-    ATTR_AUTO_UPDATE, ATTR_WEBUI, ATTR_AUDIO, ATTR_AUDIO_INPUT, ATTR_HOST_IPC,
-    ATTR_AUDIO_OUTPUT, ATTR_HASSIO_API, ATTR_BUILD_FROM, ATTR_SQUASH,
-    ATTR_ARGS, ATTR_GPIO, ATTR_HOMEASSISTANT_API, ATTR_STDIN, ATTR_LEGACY,
-    ATTR_HOST_DBUS, ATTR_AUTO_UART, ATTR_SERVICES, ATTR_DISCOVERY,
-    ATTR_APPARMOR, ATTR_DEVICETREE)
-from ..validate import NETWORK_PORT, DOCKER_PORTS, ALSA_DEVICE
+    ARCH_ALL,
+    ATTR_ACCESS_TOKEN,
+    ATTR_APPARMOR,
+    ATTR_ARCH,
+    ATTR_ARGS,
+    ATTR_AUDIO,
+    ATTR_AUDIO_INPUT,
+    ATTR_AUDIO_OUTPUT,
+    ATTR_AUTH_API,
+    ATTR_AUTO_UART,
+    ATTR_AUTO_UPDATE,
+    ATTR_BOOT,
+    ATTR_BUILD_FROM,
+    ATTR_DESCRIPTON,
+    ATTR_DEVICES,
+    ATTR_DEVICETREE,
+    ATTR_DISCOVERY,
+    ATTR_DOCKER_API,
+    ATTR_ENVIRONMENT,
+    ATTR_FULL_ACCESS,
+    ATTR_GPIO,
+    ATTR_HASSIO_API,
+    ATTR_HASSIO_ROLE,
+    ATTR_HOMEASSISTANT,
+    ATTR_HOMEASSISTANT_API,
+    ATTR_HOST_DBUS,
+    ATTR_HOST_IPC,
+    ATTR_HOST_NETWORK,
+    ATTR_HOST_PID,
+    ATTR_IMAGE,
+    ATTR_INGRESS,
+    ATTR_INGRESS_ENTRY,
+    ATTR_INGRESS_PORT,
+    ATTR_INGRESS_TOKEN,
+    ATTR_INGRESS_PANEL,
+    ATTR_PANEL_ADMIN,
+    ATTR_PANEL_ICON,
+    ATTR_PANEL_TITLE,
+    ATTR_KERNEL_MODULES,
+    ATTR_LEGACY,
+    ATTR_LOCATON,
+    ATTR_MACHINE,
+    ATTR_MAP,
+    ATTR_NAME,
+    ATTR_NETWORK,
+    ATTR_OPTIONS,
+    ATTR_PORTS,
+    ATTR_PORTS_DESCRIPTION,
+    ATTR_PRIVILEGED,
+    ATTR_PROTECTED,
+    ATTR_REPOSITORY,
+    ATTR_SCHEMA,
+    ATTR_SERVICES,
+    ATTR_SLUG,
+    ATTR_SQUASH,
+    ATTR_STARTUP,
+    ATTR_STATE,
+    ATTR_STDIN,
+    ATTR_SYSTEM,
+    ATTR_TIMEOUT,
+    ATTR_TMPFS,
+    ATTR_URL,
+    ATTR_USER,
+    ATTR_UUID,
+    ATTR_VERSION,
+    ATTR_WEBUI,
+    BOOT_AUTO,
+    BOOT_MANUAL,
+    PRIVILEGED_ALL,
+    ROLE_ALL,
+    ROLE_DEFAULT,
+    STARTUP_ALL,
+    STARTUP_APPLICATION,
+    STARTUP_SERVICES,
+    STATE_STARTED,
+    STATE_STOPPED,
+)
+from ..discovery.validate import valid_discovery_service
+from ..validate import (
+    ALSA_DEVICE,
+    DOCKER_PORTS,
+    DOCKER_PORTS_DESCRIPTION,
+    NETWORK_PORT,
+    TOKEN,
+    UUID_MATCH,
+)
 
 _LOGGER = logging.getLogger(__name__)
 
 
-RE_VOLUME = re.compile(r"^(config|ssl|addons|backup|share)(?::(rw|:ro))?$")
-RE_SERVICE = re.compile(r"^(?P<service>mqtt)(?::(?P<rights>rw|:ro))?$")
-RE_DISCOVERY = re.compile(r"^(?P<component>\w*)(?:/(?P<platform>\w*>))?$")
+RE_VOLUME = re.compile(r"^(config|ssl|addons|backup|share)(?::(rw|ro))?$")
+RE_SERVICE = re.compile(r"^(?P<service>mqtt):(?P<rights>provide|want|need)$")
 
 V_STR = 'str'
 V_INT = 'int'
@@ -46,33 +118,20 @@ RE_SCHEMA_ELEMENT = re.compile(
     r")\??$"
 )
 
+RE_DOCKER_IMAGE = re.compile(
+    r"^([a-zA-Z\-\.:\d{}]+/)*?([\-\w{}]+)/([\-\w{}]+)$")
+RE_DOCKER_IMAGE_BUILD = re.compile(
+    r"^([a-zA-Z\-\.:\d{}]+/)*?([\-\w{}]+)/([\-\w{}]+)(:[\.\-\w{}]+)?$")
+
 SCHEMA_ELEMENT = vol.Match(RE_SCHEMA_ELEMENT)
 
-ARCH_ALL = [
-    ARCH_ARMHF, ARCH_AARCH64, ARCH_AMD64, ARCH_I386
-]
 
-STARTUP_ALL = [
-    STARTUP_ONCE, STARTUP_INITIALIZE, STARTUP_SYSTEM, STARTUP_SERVICES,
-    STARTUP_APPLICATION
+MACHINE_ALL = [
+    'intel-nuc', 'odroid-c2', 'odroid-xu', 'orangepi-prime', 'qemux86',
+    'qemux86-64', 'qemuarm', 'qemuarm-64', 'raspberrypi', 'raspberrypi2',
+    'raspberrypi3', 'raspberrypi3-64', 'tinker',
 ]
 
-PRIVILEGED_ALL = [
-    "NET_ADMIN",
-    "SYS_ADMIN",
-    "SYS_RAWIO",
-    "IPC_LOCK",
-    "SYS_TIME",
-    "SYS_NICE"
-]
-
-BASE_IMAGE = {
-    ARCH_ARMHF: "homeassistant/armhf-base:latest",
-    ARCH_AARCH64: "homeassistant/aarch64-base:latest",
-    ARCH_I386: "homeassistant/i386-base:latest",
-    ARCH_AMD64: "homeassistant/amd64-base:latest",
-}
-
 
 def _simple_startup(value):
     """Simple startup schema."""
@@ -89,16 +148,26 @@ SCHEMA_ADDON_CONFIG = vol.Schema({
     vol.Required(ATTR_VERSION): vol.Coerce(str),
     vol.Required(ATTR_SLUG): vol.Coerce(str),
     vol.Required(ATTR_DESCRIPTON): vol.Coerce(str),
+    vol.Required(ATTR_ARCH): [vol.In(ARCH_ALL)],
+    vol.Optional(ATTR_MACHINE): [vol.In(MACHINE_ALL)],
     vol.Optional(ATTR_URL): vol.Url(),
-    vol.Optional(ATTR_ARCH, default=ARCH_ALL): [vol.In(ARCH_ALL)],
     vol.Required(ATTR_STARTUP):
         vol.All(_simple_startup, vol.In(STARTUP_ALL)),
     vol.Required(ATTR_BOOT):
         vol.In([BOOT_AUTO, BOOT_MANUAL]),
     vol.Optional(ATTR_PORTS): DOCKER_PORTS,
+    vol.Optional(ATTR_PORTS_DESCRIPTION): DOCKER_PORTS_DESCRIPTION,
     vol.Optional(ATTR_WEBUI):
         vol.Match(r"^(?:https?|\[PROTO:\w+\]):\/\/\[HOST\]:\[PORT:\d+\].*$"),
+    vol.Optional(ATTR_INGRESS, default=False): vol.Boolean(),
+    vol.Optional(ATTR_INGRESS_PORT, default=8099): vol.Any(NETWORK_PORT, vol.Equal(0)),
+    vol.Optional(ATTR_INGRESS_ENTRY): vol.Coerce(str),
+    vol.Optional(ATTR_PANEL_ICON, default="mdi:puzzle"): vol.Coerce(str),
+    vol.Optional(ATTR_PANEL_TITLE): vol.Coerce(str),
+    vol.Optional(ATTR_PANEL_ADMIN, default=True): vol.Boolean(),
+    vol.Optional(ATTR_HOMEASSISTANT): vol.Maybe(vol.Coerce(str)),
     vol.Optional(ATTR_HOST_NETWORK, default=False): vol.Boolean(),
+    vol.Optional(ATTR_HOST_PID, default=False): vol.Boolean(),
     vol.Optional(ATTR_HOST_IPC, default=False): vol.Boolean(),
     vol.Optional(ATTR_HOST_DBUS, default=False): vol.Boolean(),
     vol.Optional(ATTR_DEVICES): [vol.Match(r"^(.*):(.*):([rwm]{1,3})$")],
@@ -109,15 +178,20 @@ SCHEMA_ADDON_CONFIG = vol.Schema({
     vol.Optional(ATTR_ENVIRONMENT): {vol.Match(r"\w*"): vol.Coerce(str)},
     vol.Optional(ATTR_PRIVILEGED): [vol.In(PRIVILEGED_ALL)],
     vol.Optional(ATTR_APPARMOR, default=True): vol.Boolean(),
+    vol.Optional(ATTR_FULL_ACCESS, default=False): vol.Boolean(),
     vol.Optional(ATTR_AUDIO, default=False): vol.Boolean(),
     vol.Optional(ATTR_GPIO, default=False): vol.Boolean(),
     vol.Optional(ATTR_DEVICETREE, default=False): vol.Boolean(),
+    vol.Optional(ATTR_KERNEL_MODULES, default=False): vol.Boolean(),
     vol.Optional(ATTR_HASSIO_API, default=False): vol.Boolean(),
+    vol.Optional(ATTR_HASSIO_ROLE, default=ROLE_DEFAULT): vol.In(ROLE_ALL),
     vol.Optional(ATTR_HOMEASSISTANT_API, default=False): vol.Boolean(),
     vol.Optional(ATTR_STDIN, default=False): vol.Boolean(),
     vol.Optional(ATTR_LEGACY, default=False): vol.Boolean(),
+    vol.Optional(ATTR_DOCKER_API, default=False): vol.Boolean(),
+    vol.Optional(ATTR_AUTH_API, default=False): vol.Boolean(),
     vol.Optional(ATTR_SERVICES): [vol.Match(RE_SERVICE)],
-    vol.Optional(ATTR_DISCOVERY): [vol.Match(RE_DISCOVERY)],
+    vol.Optional(ATTR_DISCOVERY): [valid_discovery_service],
     vol.Required(ATTR_OPTIONS): dict,
     vol.Required(ATTR_SCHEMA): vol.Any(vol.Schema({
         vol.Coerce(str): vol.Any(SCHEMA_ELEMENT, [
@@ -129,24 +203,17 @@ SCHEMA_ADDON_CONFIG = vol.Schema({
             vol.Coerce(str): vol.Any(SCHEMA_ELEMENT, [SCHEMA_ELEMENT])
         }))
     }), False),
-    vol.Optional(ATTR_IMAGE): vol.Match(r"^[\w{}]+/[\-\w{}]+$"),
+    vol.Optional(ATTR_IMAGE):
+        vol.Match(RE_DOCKER_IMAGE),
     vol.Optional(ATTR_TIMEOUT, default=10):
         vol.All(vol.Coerce(int), vol.Range(min=10, max=120)),
 }, extra=vol.REMOVE_EXTRA)
 
 
-# pylint: disable=no-value-for-parameter
-SCHEMA_REPOSITORY_CONFIG = vol.Schema({
-    vol.Required(ATTR_NAME): vol.Coerce(str),
-    vol.Optional(ATTR_URL): vol.Url(),
-    vol.Optional(ATTR_MAINTAINER): vol.Coerce(str),
-}, extra=vol.REMOVE_EXTRA)
-
-
 # pylint: disable=no-value-for-parameter
 SCHEMA_BUILD_CONFIG = vol.Schema({
-    vol.Optional(ATTR_BUILD_FROM, default=BASE_IMAGE): vol.Schema({
-        vol.In(ARCH_ALL): vol.Match(r"(?:^[\w{}]+/)?[\-\w{}]+:[\.\-\w{}]+$"),
+    vol.Optional(ATTR_BUILD_FROM, default=dict): vol.Schema({
+        vol.In(ARCH_ALL): vol.Match(RE_DOCKER_IMAGE_BUILD),
     }),
     vol.Optional(ATTR_SQUASH, default=False): vol.Boolean(),
     vol.Optional(ATTR_ARGS, default=dict): vol.Schema({
@@ -158,8 +225,10 @@ SCHEMA_BUILD_CONFIG = vol.Schema({
 # pylint: disable=no-value-for-parameter
 SCHEMA_ADDON_USER = vol.Schema({
     vol.Required(ATTR_VERSION): vol.Coerce(str),
-    vol.Optional(ATTR_UUID, default=lambda: uuid.uuid4().hex):
-        vol.Match(r"^[0-9a-f]{32}$"),
+    vol.Optional(ATTR_IMAGE): vol.Coerce(str),
+    vol.Optional(ATTR_UUID, default=lambda: uuid.uuid4().hex): UUID_MATCH,
+    vol.Optional(ATTR_ACCESS_TOKEN): TOKEN,
+    vol.Optional(ATTR_INGRESS_TOKEN, default=secrets.token_urlsafe): vol.Coerce(str),
     vol.Optional(ATTR_OPTIONS, default=dict): dict,
     vol.Optional(ATTR_AUTO_UPDATE, default=False): vol.Boolean(),
     vol.Optional(ATTR_BOOT):
@@ -167,6 +236,8 @@ SCHEMA_ADDON_USER = vol.Schema({
     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)
 
 
@@ -197,7 +268,7 @@ SCHEMA_ADDON_SNAPSHOT = vol.Schema({
 def validate_options(raw_schema):
     """Validate schema."""
     def validate(struct):
-        """Create schema validator for addons options."""
+        """Create schema validator for add-ons options."""
         options = {}
 
         # read options

hassio/api/__init__.py

@@ -1,40 +1,44 @@
-"""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 .homeassistant import APIHomeAssistant
 from .hardware import APIHardware
-from .host import APIHost
 from .hassos import APIHassOS
+from .homeassistant import APIHomeAssistant
+from .host import APIHost
+from .info import APIInfo
+from .ingress import APIIngress
 from .proxy import APIProxy
-from .supervisor import APISupervisor
-from .snapshots import APISnapshots
-from .services import APIServices
 from .security import SecurityMiddleware
-from ..coresys import CoreSysAttributes
+from .services import APIServices
+from .snapshots import APISnapshots
+from .supervisor import APISupervisor
 
 _LOGGER = logging.getLogger(__name__)
 
 
 class RestAPI(CoreSysAttributes):
-    """Handle rest api for hassio."""
+    """Handle RESTful API for Hass.io."""
 
-    def __init__(self, coresys):
-        """Initialize docker base wrapper."""
-        self.coresys = coresys
-        self.security = SecurityMiddleware(coresys)
-        self.webapp = web.Application(
-            middlewares=[self.security.token_validation], loop=coresys.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._runner = web.AppRunner(self.webapp)
-        self._site = None
+        self._runner: web.AppRunner = web.AppRunner(self.webapp)
+        self._site: Optional[web.TCPSite] = None
 
-    async def load(self):
+    async def load(self) -> None:
         """Register REST API Calls."""
         self._register_supervisor()
         self._register_host()
@@ -44,12 +48,15 @@ class RestAPI(CoreSysAttributes):
         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()
 
-    def _register_host(self):
-        """Register hostcontrol function."""
+    def _register_host(self) -> None:
+        """Register hostcontrol functions."""
         api_host = APIHost()
         api_host.coresys = self.coresys
 
@@ -58,28 +65,30 @@ class RestAPI(CoreSysAttributes):
             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),
+            web.post('/host/services/{service}/restart',
+                     api_host.service_restart),
+            web.post('/host/services/{service}/reload',
+                     api_host.service_reload),
         ])
 
-    def _register_hassos(self):
-        """Register hassos function."""
+    def _register_hassos(self) -> None:
+        """Register HassOS functions."""
         api_hassos = APIHassOS()
         api_hassos.coresys = self.coresys
 
         self.webapp.add_routes([
             web.get('/hassos/info', api_hassos.info),
             web.post('/hassos/update', api_hassos.update),
+            web.post('/hassos/update/cli', api_hassos.update_cli),
             web.post('/hassos/config/sync', api_hassos.config_sync),
         ])
 
-    def _register_hardware(self):
-        """Register hardware function."""
+    def _register_hardware(self) -> None:
+        """Register hardware functions."""
         api_hardware = APIHardware()
         api_hardware.coresys = self.coresys
 
@@ -88,8 +97,26 @@ class RestAPI(CoreSysAttributes):
             web.get('/hardware/audio', api_hardware.audio),
         ])
 
-    def _register_supervisor(self):
-        """Register supervisor function."""
+    def _register_info(self) -> None:
+        """Register info functions."""
+        api_info = APIInfo()
+        api_info.coresys = self.coresys
+
+        self.webapp.add_routes([
+            web.get('/info', api_info.info),
+        ])
+
+    def _register_auth(self) -> None:
+        """Register auth functions."""
+        api_auth = APIAuth()
+        api_auth.coresys = self.coresys
+
+        self.webapp.add_routes([
+            web.post('/auth', api_auth.auth),
+        ])
+
+    def _register_supervisor(self) -> None:
+        """Register Supervisor functions."""
         api_supervisor = APISupervisor()
         api_supervisor.coresys = self.coresys
 
@@ -103,8 +130,8 @@ class RestAPI(CoreSysAttributes):
             web.post('/supervisor/options', api_supervisor.options),
         ])
 
-    def _register_homeassistant(self):
-        """Register homeassistant function."""
+    def _register_homeassistant(self) -> None:
+        """Register Home Assistant functions."""
         api_hass = APIHomeAssistant()
         api_hass.coresys = self.coresys
 
@@ -118,10 +145,11 @@ class RestAPI(CoreSysAttributes):
             web.post('/homeassistant/stop', api_hass.stop),
             web.post('/homeassistant/start', api_hass.start),
             web.post('/homeassistant/check', api_hass.check),
+            web.post('/homeassistant/rebuild', api_hass.rebuild),
         ])
 
-    def _register_proxy(self):
-        """Register HomeAssistant API Proxy."""
+    def _register_proxy(self) -> None:
+        """Register Home Assistant API Proxy."""
         api_proxy = APIProxy()
         api_proxy.coresys = self.coresys
 
@@ -134,8 +162,8 @@ class RestAPI(CoreSysAttributes):
             web.get('/homeassistant/api/', api_proxy.api),
         ])
 
-    def _register_addons(self):
-        """Register homeassistant function."""
+    def _register_addons(self) -> None:
+        """Register Add-on functions."""
         api_addons = APIAddons()
         api_addons.coresys = self.coresys
 
@@ -156,11 +184,23 @@ class RestAPI(CoreSysAttributes):
             web.get('/addons/{addon}/logo', api_addons.logo),
             web.get('/addons/{addon}/changelog', api_addons.changelog),
             web.post('/addons/{addon}/stdin', api_addons.stdin),
+            web.post('/addons/{addon}/security', api_addons.security),
             web.get('/addons/{addon}/stats', api_addons.stats),
         ])
 
-    def _register_snapshots(self):
-        """Register snapshots function."""
+    def _register_ingress(self) -> None:
+        """Register Ingress functions."""
+        api_ingress = APIIngress()
+        api_ingress.coresys = self.coresys
+
+        self.webapp.add_routes([
+            web.post('/ingress/session', api_ingress.create_session),
+            web.get('/ingress/panels', api_ingress.panels),
+            web.view('/ingress/{token}/{path:.*}', api_ingress.handler),
+        ])
+
+    def _register_snapshots(self) -> None:
+        """Register snapshots functions."""
         api_snapshots = APISnapshots()
         api_snapshots.coresys = self.coresys
 
@@ -179,7 +219,8 @@ class RestAPI(CoreSysAttributes):
             web.get('/snapshots/{snapshot}/download', api_snapshots.download),
         ])
 
-    def _register_services(self):
+    def _register_services(self) -> None:
+        """Register services functions."""
         api_services = APIServices()
         api_services.coresys = self.coresys
 
@@ -190,58 +231,44 @@ class RestAPI(CoreSysAttributes):
             web.delete('/services/{service}', api_services.del_service),
         ])
 
-    def _register_discovery(self):
+    def _register_discovery(self) -> None:
+        """Register discovery functions."""
         api_discovery = APIDiscovery()
         api_discovery.coresys = self.coresys
 
         self.webapp.add_routes([
-            web.get('/services/discovery', api_discovery.list),
-            web.get('/services/discovery/{uuid}', api_discovery.get_discovery),
-            web.delete('/services/discovery/{uuid}',
-                       api_discovery.del_discovery),
-            web.post('/services/discovery', api_discovery.set_discovery),
+            web.get('/discovery', api_discovery.list),
+            web.get('/discovery/{uuid}', api_discovery.get_discovery),
+            web.delete('/discovery/{uuid}', api_discovery.del_discovery),
+            web.post('/discovery', api_discovery.set_discovery),
         ])
 
-    def _register_panel(self):
-        """Register panel for homeassistant."""
+    def _register_panel(self) -> None:
+        """Register panel for Home Assistant."""
         panel_dir = Path(__file__).parent.joinpath("panel")
-
-        def create_response(panel_file):
-            """Create a function to generate a response."""
-            path = panel_dir.joinpath(f"{panel_file!s}.html")
-            return lambda request: web.FileResponse(path)
-
-        # This route is for backwards compatibility with HA < 0.58
-        self.webapp.add_routes([
-            web.get('/panel', create_response('hassio-main-es5'))])
-
-        # This route is for backwards compatibility with HA 0.58 - 0.61
-        self.webapp.add_routes([
-            web.get('/panel_es5', create_response('hassio-main-es5')),
-            web.get('/panel_latest', create_response('hassio-main-latest')),
-        ])
-
-        # This route is for backwards compatibility with HA 0.62 - 0.70
-        self.webapp.add_routes([
-            web.get('/app-es5/index.html', create_response('index')),
-            web.get('/app-es5/hassio-app.html', create_response('hassio-app')),
-        ])
-
-        # This route is for HA > 0.70
         self.webapp.add_routes([web.static('/app', panel_dir)])
 
-    async def start(self):
-        """Run rest api webserver."""
+    async def start(self) -> None:
+        """Run RESTful API webserver."""
         await self._runner.setup()
-        self._site = web.TCPSite(self._runner, "0.0.0.0", 80)
+        self._site = web.TCPSite(
+            self._runner, host="0.0.0.0", port=80, shutdown_timeout=5)
 
         try:
             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."""
+    async def stop(self) -> None:
+        """Stop RESTful API webserver."""
+        if not self._site:
+            return
+
+        # Shutdown running API
         await self._site.stop()
         await self._runner.cleanup()
+
+        _LOGGER.info("Stop API on %s", self.sys_docker.network.supervisor)

hassio/api/addons.py

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

hassio/api/auth.py

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

hassio/api/discovery.py

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

hassio/api/hardware.py

@@ -1,4 +1,4 @@
-"""Init file for HassIO hardware rest api."""
+"""Init file for Hass.io hardware RESTful API."""
 import logging
 
 from .utils import api_process
@@ -10,7 +10,7 @@ _LOGGER = logging.getLogger(__name__)
 
 
 class APIHardware(CoreSysAttributes):
-    """Handle rest api for hardware functions."""
+    """Handle RESTful API for hardware functions."""
 
     @api_process
     async def info(self, request):

hassio/api/hassos.py

@@ -1,34 +1,42 @@
-"""Init file for Hass.io hassos rest api."""
+"""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 .utils import api_process, api_validate
-from ..const import ATTR_VERSION, ATTR_BOARD, ATTR_VERSION_LATEST
+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),
-})
+SCHEMA_VERSION = vol.Schema({vol.Optional(ATTR_VERSION): vol.Coerce(str)})
 
 
 class APIHassOS(CoreSysAttributes):
-    """Handle rest api for hassos functions."""
+    """Handle RESTful API for HassOS functions."""
 
     @api_process
-    async def info(self, request):
-        """Return hassos information."""
+    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):
+    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)
@@ -36,6 +44,14 @@ class APIHassOS(CoreSysAttributes):
         await asyncio.shield(self.sys_hassos.update(version))
 
     @api_process
-    def config_sync(self, request):
+    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,52 +1,72 @@
-"""Init file for HassIO homeassistant rest api."""
+"""Init file for Hass.io Home Assistant RESTful API."""
 import asyncio
 import logging
+from typing import Coroutine, Dict, Any
 
 import voluptuous as vol
+from aiohttp import web
 
-from .utils import api_process, api_process_raw, api_validate
 from ..const import (
-    ATTR_VERSION, ATTR_LAST_VERSION, ATTR_IMAGE, ATTR_CUSTOM, ATTR_BOOT,
-    ATTR_PORT, ATTR_PASSWORD, ATTR_SSL, ATTR_WATCHDOG, ATTR_CPU_PERCENT,
-    ATTR_MEMORY_USAGE, ATTR_MEMORY_LIMIT, ATTR_NETWORK_RX, ATTR_NETWORK_TX,
-    ATTR_BLK_READ, ATTR_BLK_WRITE, ATTR_WAIT_BOOT, ATTR_MACHINE,
-    CONTENT_TYPE_BINARY)
+    ATTR_ARCH,
+    ATTR_BLK_READ,
+    ATTR_BLK_WRITE,
+    ATTR_BOOT,
+    ATTR_CPU_PERCENT,
+    ATTR_CUSTOM,
+    ATTR_IMAGE,
+    ATTR_LAST_VERSION,
+    ATTR_MACHINE,
+    ATTR_MEMORY_LIMIT,
+    ATTR_MEMORY_USAGE,
+    ATTR_NETWORK_RX,
+    ATTR_NETWORK_TX,
+    ATTR_PASSWORD,
+    ATTR_PORT,
+    ATTR_REFRESH_TOKEN,
+    ATTR_SSL,
+    ATTR_VERSION,
+    ATTR_WAIT_BOOT,
+    ATTR_WATCHDOG,
+    ATTR_IP_ADDRESS,
+    CONTENT_TYPE_BINARY,
+)
 from ..coresys import CoreSysAttributes
-from ..validate import NETWORK_PORT, DOCKER_IMAGE
+from ..exceptions import APIError
+from ..validate import DOCKER_IMAGE, NETWORK_PORT
+from .utils import api_process, api_process_raw, api_validate
 
 _LOGGER = logging.getLogger(__name__)
 
-
 # pylint: disable=no-value-for-parameter
-SCHEMA_OPTIONS = vol.Schema({
-    vol.Optional(ATTR_BOOT): vol.Boolean(),
-    vol.Inclusive(ATTR_IMAGE, 'custom_hass'):
-        vol.Any(None, vol.Coerce(str)),
-    vol.Inclusive(ATTR_LAST_VERSION, 'custom_hass'):
-        vol.Any(None, DOCKER_IMAGE),
-    vol.Optional(ATTR_PORT): NETWORK_PORT,
-    vol.Optional(ATTR_PASSWORD): vol.Any(None, vol.Coerce(str)),
-    vol.Optional(ATTR_SSL): vol.Boolean(),
-    vol.Optional(ATTR_WATCHDOG): vol.Boolean(),
-    vol.Optional(ATTR_WAIT_BOOT):
-        vol.All(vol.Coerce(int), vol.Range(min=60)),
-})
+SCHEMA_OPTIONS = vol.Schema(
+    {
+        vol.Optional(ATTR_BOOT): vol.Boolean(),
+        vol.Inclusive(ATTR_IMAGE, "custom_hass"): vol.Maybe(DOCKER_IMAGE),
+        vol.Inclusive(ATTR_LAST_VERSION, "custom_hass"): vol.Maybe(vol.Coerce(str)),
+        vol.Optional(ATTR_PORT): NETWORK_PORT,
+        vol.Optional(ATTR_PASSWORD): vol.Maybe(vol.Coerce(str)),
+        vol.Optional(ATTR_SSL): vol.Boolean(),
+        vol.Optional(ATTR_WATCHDOG): vol.Boolean(),
+        vol.Optional(ATTR_WAIT_BOOT): vol.All(vol.Coerce(int), vol.Range(min=60)),
+        vol.Optional(ATTR_REFRESH_TOKEN): vol.Maybe(vol.Coerce(str)),
+    }
+)
 
-SCHEMA_VERSION = vol.Schema({
-    vol.Optional(ATTR_VERSION): vol.Coerce(str),
-})
+SCHEMA_VERSION = vol.Schema({vol.Optional(ATTR_VERSION): vol.Coerce(str)})
 
 
 class APIHomeAssistant(CoreSysAttributes):
-    """Handle rest api for homeassistant functions."""
+    """Handle RESTful API for Home Assistant functions."""
 
     @api_process
-    async def info(self, request):
+    async def info(self, request: web.Request) -> Dict[str, Any]:
         """Return host information."""
         return {
             ATTR_VERSION: self.sys_homeassistant.version,
-            ATTR_LAST_VERSION: self.sys_homeassistant.last_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,
@@ -57,13 +77,13 @@ class APIHomeAssistant(CoreSysAttributes):
         }
 
     @api_process
-    async def options(self, request):
-        """Set homeassistant options."""
+    async def options(self, request: web.Request) -> None:
+        """Set Home Assistant options."""
         body = await api_validate(SCHEMA_OPTIONS, request)
 
         if ATTR_IMAGE in body and ATTR_LAST_VERSION in body:
             self.sys_homeassistant.image = body[ATTR_IMAGE]
-            self.sys_homeassistant.last_version = body[ATTR_LAST_VERSION]
+            self.sys_homeassistant.latest_version = body[ATTR_LAST_VERSION]
 
         if ATTR_BOOT in body:
             self.sys_homeassistant.boot = body[ATTR_BOOT]
@@ -73,6 +93,7 @@ class APIHomeAssistant(CoreSysAttributes):
 
         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]
@@ -83,15 +104,18 @@ class APIHomeAssistant(CoreSysAttributes):
         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()
-        return True
 
     @api_process
-    async def stats(self, request):
+    async def stats(self, request: web.Request) -> Dict[Any, str]:
         """Return resource information."""
         stats = await self.sys_homeassistant.stats()
         if not stats:
-            raise RuntimeError("No stats available")
+            raise APIError("No stats available")
 
         return {
             ATTR_CPU_PERCENT: stats.cpu_percent,
@@ -104,42 +128,41 @@ class APIHomeAssistant(CoreSysAttributes):
         }
 
     @api_process
-    async def update(self, request):
-        """Update homeassistant."""
+    async def update(self, request: web.Request) -> None:
+        """Update Home Assistant."""
         body = await api_validate(SCHEMA_VERSION, request)
-        version = body.get(ATTR_VERSION, self.sys_homeassistant.last_version)
+        version = body.get(ATTR_VERSION, self.sys_homeassistant.latest_version)
 
-        if version == self.sys_homeassistant.version:
-            raise RuntimeError("Version {} is already in use".format(version))
-
-        return await asyncio.shield(
-            self.sys_homeassistant.update(version))
+        await asyncio.shield(self.sys_homeassistant.update(version))
 
     @api_process
-    def stop(self, request):
-        """Stop homeassistant."""
+    def stop(self, request: web.Request) -> Coroutine:
+        """Stop Home Assistant."""
         return asyncio.shield(self.sys_homeassistant.stop())
 
     @api_process
-    def start(self, request):
-        """Start homeassistant."""
+    def start(self, request: web.Request) -> Coroutine:
+        """Start Home Assistant."""
         return asyncio.shield(self.sys_homeassistant.start())
 
     @api_process
-    def restart(self, request):
-        """Restart homeassistant."""
+    def restart(self, request: web.Request) -> Coroutine:
+        """Restart Home Assistant."""
         return asyncio.shield(self.sys_homeassistant.restart())
 
+    @api_process
+    def rebuild(self, request: web.Request) -> Coroutine:
+        """Rebuild Home Assistant."""
+        return asyncio.shield(self.sys_homeassistant.rebuild())
+
     @api_process_raw(CONTENT_TYPE_BINARY)
-    def logs(self, request):
-        """Return homeassistant docker logs."""
+    def logs(self, request: web.Request) -> Coroutine:
+        """Return Home Assistant Docker logs."""
         return self.sys_homeassistant.logs()
 
     @api_process
-    async def check(self, request):
-        """Check config of homeassistant."""
+    async def check(self, request: web.Request) -> None:
+        """Check configuration of Home Assistant."""
         result = await self.sys_homeassistant.check_config()
         if not result.valid:
-            raise RuntimeError(result.log)
-
-        return True
+            raise APIError(result.log)

hassio/api/host.py

@@ -1,4 +1,4 @@
-"""Init file for HassIO host rest api."""
+"""Init file for Hass.io host RESTful API."""
 import asyncio
 import logging
 
@@ -21,7 +21,7 @@ SCHEMA_OPTIONS = vol.Schema({
 
 
 class APIHost(CoreSysAttributes):
-    """Handle rest api for host functions."""
+    """Handle RESTful API for host functions."""
 
     @api_process
     async def info(self, request):

hassio/api/info.py

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

hassio/api/ingress.py

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

hassio/api/panel/chunk.c93f37c558ff32991708.js

@@ -1 +0,0 @@
-(window.webpackJsonp=window.webpackJsonp||[]).push([[5],{104: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(99),i=t.n(e),o=t(97),u=t.n(o),a=i.a,c=u.a}}]);

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

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

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

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

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

@@ -1,389 +0,0 @@
-/**
-@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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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
-*/
-
-/**
-@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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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/entrypoint.js

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

hassio/api/proxy.py

@@ -1,71 +1,75 @@
-"""Utils for HomeAssistant Proxy."""
+"""Utils for Home Assistant Proxy."""
 import asyncio
+from contextlib import asynccontextmanager
 import logging
 
 import aiohttp
 from aiohttp import web
-from aiohttp.web_exceptions import HTTPBadGateway, HTTPInternalServerError
-from aiohttp.hdrs import CONTENT_TYPE
+from aiohttp.web_exceptions import HTTPBadGateway, HTTPUnauthorized
+from aiohttp.client_exceptions import ClientConnectorError
+from aiohttp.hdrs import CONTENT_TYPE, AUTHORIZATION
 import async_timeout
 
 from ..const import HEADER_HA_ACCESS
 from ..coresys import CoreSysAttributes
+from ..exceptions import (
+    HomeAssistantAuthError, HomeAssistantAPIError, APIError)
 
 _LOGGER = logging.getLogger(__name__)
 
 
 class APIProxy(CoreSysAttributes):
-    """API Proxy for Home-Assistant."""
+    """API Proxy for Home Assistant."""
 
     def _check_access(self, request):
         """Check the Hass.io token."""
-        hassio_token = request.headers.get(HEADER_HA_ACCESS)
-        addon = self.sys_addons.from_uuid(hassio_token)
-
-        if not addon:
-            _LOGGER.warning("Unknown Home-Assistant API access!")
+        if AUTHORIZATION in request.headers:
+            bearer = request.headers[AUTHORIZATION]
+            hassio_token = bearer.split(' ')[-1]
         else:
-            _LOGGER.info("%s access from %s", request.path, addon.slug)
+            hassio_token = request.headers.get(HEADER_HA_ACCESS)
 
+        addon = self.sys_addons.from_token(hassio_token)
+        if not addon:
+            _LOGGER.warning("Unknown Home Assistant API access!")
+        elif not addon.access_homeassistant_api:
+            _LOGGER.warning("Not permitted API access: %s", addon.slug)
+        else:
+            _LOGGER.debug("%s access from %s", request.path, addon.slug)
+            return
+
+        raise HTTPUnauthorized()
+
+    @asynccontextmanager
     async def _api_client(self, request, path, timeout=300):
-        """Return a client request with proxy origin for Home-Assistant."""
-        url = f"{self.sys_homeassistant.api_url}/api/{path}"
-
+        """Return a client request with proxy origin for Home Assistant."""
         try:
-            data = None
-            headers = {}
-            method = getattr(self.sys_websession_ssl, request.method.lower())
-            params = request.query or None
-
             # read data
             with async_timeout.timeout(30):
                 data = await request.read()
 
             if data:
-                headers.update({CONTENT_TYPE: request.content_type})
+                content_type = request.content_type
+            else:
+                content_type = None
 
-            # need api password?
-            if self.sys_homeassistant.api_password:
-                headers = {
-                    HEADER_HA_ACCESS: self.sys_homeassistant.api_password,
-                }
-
-            # reset headers
-            if not headers:
-                headers = None
-
-            client = await method(
-                url, data=data, headers=headers, timeout=timeout,
-                params=params
-            )
-
-            return client
+            async with self.sys_homeassistant.make_request(
+                    request.method.lower(), f'api/{path}',
+                    content_type=content_type,
+                    data=data,
+                    timeout=timeout,
+            ) as resp:
+                yield resp
+                return
 
+        except HomeAssistantAuthError:
+            _LOGGER.error("Authenticate error on API for request %s", path)
+        except HomeAssistantAPIError:
+            _LOGGER.error("Error on API for request %s", path)
         except aiohttp.ClientError as err:
-            _LOGGER.error("Client error on API %s request %s.", path, err)
-
+            _LOGGER.error("Client error on API %s request %s", path, err)
         except asyncio.TimeoutError:
-            _LOGGER.error("Client timeout error on API request %s.", path)
+            _LOGGER.error("Client timeout error on API request %s", path)
 
         raise HTTPBadGateway()
 
@@ -73,79 +77,92 @@ class APIProxy(CoreSysAttributes):
         """Proxy HomeAssistant EventStream Requests."""
         self._check_access(request)
 
-        _LOGGER.info("Home-Assistant EventStream start")
-        client = await self._api_client(request, 'stream', timeout=None)
+        _LOGGER.info("Home Assistant EventStream start")
+        async with self._api_client(request, 'stream', timeout=None) as client:
+            response = web.StreamResponse()
+            response.content_type = request.headers.get(CONTENT_TYPE)
+            try:
+                await response.prepare(request)
+                async for data in client.content:
+                    await response.write(data)
 
-        response = web.StreamResponse()
-        response.content_type = request.headers.get(CONTENT_TYPE)
-        try:
-            await response.prepare(request)
-            while True:
-                data = await client.content.read(10)
-                if not data:
-                    await response.write_eof()
-                    break
-                await response.write(data)
+            except (aiohttp.ClientError, aiohttp.ClientPayloadError):
+                pass
 
-        except aiohttp.ClientError:
-            await response.write_eof()
-
-        except asyncio.CancelledError:
-            pass
-
-        finally:
-            client.close()
-            _LOGGER.info("Home-Assistant EventStream close")
-
-        return response
+            _LOGGER.info("Home Assistant EventStream close")
+            return response
 
     async def api(self, request):
-        """Proxy HomeAssistant API Requests."""
+        """Proxy Home Assistant API Requests."""
         self._check_access(request)
 
         # Normal request
         path = request.match_info.get('path', '')
-        client = await self._api_client(request, path)
-
-        data = await client.read()
-        return web.Response(
-            body=data,
-            status=client.status,
-            content_type=client.content_type
-        )
+        async with self._api_client(request, path) as client:
+            data = await client.read()
+            return web.Response(
+                body=data,
+                status=client.status,
+                content_type=client.content_type
+            )
 
     async def _websocket_client(self):
-        """Initialize a websocket api connection."""
+        """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=60, verify_ssl=False)
+                url, heartbeat=30, verify_ssl=False)
 
-            # handle authentication
-            for _ in range(2):
-                data = await client.receive_json()
-                if data.get('type') == 'auth_ok':
-                    return client
-                elif data.get('type') == 'auth_required':
-                    await client.send_json({
-                        'type': 'auth',
-                        'api_password': self.sys_homeassistant.api_password,
-                    })
+            # Handle authentication
+            data = await client.receive_json()
 
-            _LOGGER.error("Authentication to Home-Assistant websocket")
+            if data.get('type') == 'auth_ok':
+                return client
 
-        except (aiohttp.ClientError, RuntimeError) as err:
-            _LOGGER.error("Client error on websocket API %s.", err)
+            if data.get('type') != 'auth_required':
+                # Invalid protocol
+                _LOGGER.error(
+                    "Got unexpected response from HA WebSocket: %s", data)
+                raise APIError()
 
-        raise HTTPBadGateway()
+            if self.sys_homeassistant.refresh_token:
+                await self.sys_homeassistant.ensure_access_token()
+                await client.send_json({
+                    'type': 'auth',
+                    'access_token': self.sys_homeassistant.access_token,
+                })
+            else:
+                await client.send_json({
+                    'type': 'auth',
+                    'api_password': self.sys_homeassistant.api_password,
+                })
+
+            data = await client.receive_json()
+
+            if data.get('type') == 'auth_ok':
+                return client
+
+            # Renew the Token is invalid
+            if data.get('type') == 'invalid_auth' and self.sys_homeassistant.refresh_token:
+                self.sys_homeassistant.access_token = None
+                return await self._websocket_client()
+
+            raise HomeAssistantAuthError()
+
+        except (RuntimeError, ValueError, ClientConnectorError) as err:
+            _LOGGER.error("Client error on WebSocket API %s.", err)
+        except HomeAssistantAuthError:
+            _LOGGER.error("Failed authentication to Home Assistant WebSocket")
+
+        raise APIError()
 
     async def websocket(self, request):
-        """Initialize a websocket api connection."""
-        _LOGGER.info("Home-Assistant Websocket API request initialze")
+        """Initialize a WebSocket API connection."""
+        _LOGGER.info("Home Assistant WebSocket API request initialize")
 
         # init server
-        server = web.WebSocketResponse(heartbeat=60)
+        server = web.WebSocketResponse(heartbeat=30)
         await server.prepare(request)
 
         # handle authentication
@@ -157,13 +174,18 @@ class APIProxy(CoreSysAttributes):
 
             # Check API access
             response = await server.receive_json()
-            hassio_token = response.get('api_password')
-            addon = self.sys_addons.from_uuid(hassio_token)
+            hassio_token = response.get('api_password') or response.get('access_token')
+            addon = self.sys_addons.from_token(hassio_token)
 
-            if not addon:
-                _LOGGER.warning("Unauthorized websocket access!")
-            else:
-                _LOGGER.info("Websocket access from %s", addon.slug)
+            if not addon or not addon.access_homeassistant_api:
+                _LOGGER.warning("Unauthorized WebSocket access!")
+                await server.send_json({
+                    'type': 'auth_invalid',
+                    'message': 'Invalid access',
+                })
+                return server
+
+            _LOGGER.info("WebSocket access from %s", addon.slug)
 
             await server.send_json({
                 'type': 'auth_ok',
@@ -171,12 +193,15 @@ class APIProxy(CoreSysAttributes):
             })
         except (RuntimeError, ValueError) as err:
             _LOGGER.error("Can't initialize handshake: %s", err)
-            raise HTTPInternalServerError() from None
+            return server
 
         # init connection to hass
-        client = await self._websocket_client()
+        try:
+            client = await self._websocket_client()
+        except APIError:
+            return server
 
-        _LOGGER.info("Home-Assistant Websocket API request running")
+        _LOGGER.info("Home Assistant WebSocket API request running")
         try:
             client_read = None
             server_read = None
@@ -209,8 +234,8 @@ class APIProxy(CoreSysAttributes):
         except asyncio.CancelledError:
             pass
 
-        except RuntimeError as err:
-            _LOGGER.info("Home-Assistant Websocket API error: %s", err)
+        except (RuntimeError, ConnectionError, TypeError) as err:
+            _LOGGER.info("Home Assistant WebSocket API error: %s", err)
 
         finally:
             if client_read:
@@ -219,8 +244,10 @@ class APIProxy(CoreSysAttributes):
                 server_read.cancel()
 
             # close connections
-            await client.close()
-            await server.close()
+            if not client.closed:
+                await client.close()
+            if not server.closed:
+                await server.close()
 
-        _LOGGER.info("Home-Assistant Websocket API connection is closed")
+        _LOGGER.info("Home Assistant WebSocket API connection is closed")
         return server

hassio/api/security.py

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

hassio/api/services.py

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

hassio/api/snapshots.py

@@ -1,4 +1,4 @@
-"""Init file for HassIO snapshot rest api."""
+"""Init file for Hass.io snapshot RESTful API."""
 import asyncio
 import logging
 from pathlib import Path
@@ -14,6 +14,7 @@ from ..const import (
     ATTR_HOMEASSISTANT, ATTR_VERSION, ATTR_SIZE, ATTR_FOLDERS, ATTR_TYPE,
     ATTR_SNAPSHOTS, ATTR_PASSWORD, ATTR_PROTECTED, CONTENT_TYPE_TAR)
 from ..coresys import CoreSysAttributes
+from ..exceptions import APIError
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -46,13 +47,13 @@ SCHEMA_SNAPSHOT_PARTIAL = SCHEMA_SNAPSHOT_FULL.extend({
 
 
 class APISnapshots(CoreSysAttributes):
-    """Handle rest api for snapshot functions."""
+    """Handle RESTful API for snapshot functions."""
 
     def _extract_snapshot(self, request):
         """Return snapshot, throw an exception if it doesn't exist."""
         snapshot = self.sys_snapshots.get(request.match_info.get('snapshot'))
         if not snapshot:
-            raise RuntimeError("Snapshot does not exist")
+            raise APIError("Snapshot does not exist")
         return snapshot
 
     @api_process

hassio/api/supervisor.py

@@ -1,74 +1,109 @@
-"""Init file for HassIO supervisor rest api."""
+"""Init file for Hass.io Supervisor RESTful API."""
 import asyncio
 import logging
+from typing import Any, Awaitable, Dict
 
+from aiohttp import web
 import voluptuous as vol
 
-from .utils import api_process, api_process_raw, api_validate
 from ..const import (
-    ATTR_ADDONS, ATTR_VERSION, ATTR_LAST_VERSION, ATTR_CHANNEL, ATTR_ARCH,
-    HASSIO_VERSION, ATTR_ADDONS_REPOSITORIES, ATTR_LOGO, ATTR_REPOSITORY,
-    ATTR_DESCRIPTON, ATTR_NAME, ATTR_SLUG, ATTR_INSTALLED, ATTR_TIMEZONE,
-    ATTR_STATE, ATTR_WAIT_BOOT, ATTR_CPU_PERCENT, ATTR_MEMORY_USAGE,
-    ATTR_MEMORY_LIMIT, ATTR_NETWORK_RX, ATTR_NETWORK_TX, ATTR_BLK_READ,
-    ATTR_BLK_WRITE, CONTENT_TYPE_BINARY, ATTR_ICON)
+    ATTR_ADDONS,
+    ATTR_ADDONS_REPOSITORIES,
+    ATTR_ARCH,
+    ATTR_BLK_READ,
+    ATTR_BLK_WRITE,
+    ATTR_CHANNEL,
+    ATTR_CPU_PERCENT,
+    ATTR_DEBUG,
+    ATTR_DEBUG_BLOCK,
+    ATTR_DESCRIPTON,
+    ATTR_ICON,
+    ATTR_INSTALLED,
+    ATTR_IP_ADDRESS,
+    ATTR_LAST_VERSION,
+    ATTR_LOGGING,
+    ATTR_LOGO,
+    ATTR_MEMORY_LIMIT,
+    ATTR_MEMORY_USAGE,
+    ATTR_NAME,
+    ATTR_NETWORK_RX,
+    ATTR_NETWORK_TX,
+    ATTR_REPOSITORY,
+    ATTR_SLUG,
+    ATTR_STATE,
+    ATTR_TIMEZONE,
+    ATTR_VERSION,
+    ATTR_WAIT_BOOT,
+    CONTENT_TYPE_BINARY,
+    HASSIO_VERSION,
+)
 from ..coresys import CoreSysAttributes
-from ..validate import validate_timezone, WAIT_BOOT, REPOSITORIES, CHANNELS
+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({
-    vol.Optional(ATTR_CHANNEL): CHANNELS,
-    vol.Optional(ATTR_ADDONS_REPOSITORIES): REPOSITORIES,
-    vol.Optional(ATTR_TIMEZONE): validate_timezone,
-    vol.Optional(ATTR_WAIT_BOOT): WAIT_BOOT,
-})
+# pylint: disable=no-value-for-parameter
+SCHEMA_OPTIONS = vol.Schema(
+    {
+        vol.Optional(ATTR_CHANNEL): CHANNELS,
+        vol.Optional(ATTR_ADDONS_REPOSITORIES): REPOSITORIES,
+        vol.Optional(ATTR_TIMEZONE): validate_timezone,
+        vol.Optional(ATTR_WAIT_BOOT): WAIT_BOOT,
+        vol.Optional(ATTR_LOGGING): LOG_LEVEL,
+        vol.Optional(ATTR_DEBUG): vol.Boolean(),
+        vol.Optional(ATTR_DEBUG_BLOCK): vol.Boolean(),
+    }
+)
 
-SCHEMA_VERSION = vol.Schema({
-    vol.Optional(ATTR_VERSION): vol.Coerce(str),
-})
+SCHEMA_VERSION = vol.Schema({vol.Optional(ATTR_VERSION): vol.Coerce(str)})
 
 
 class APISupervisor(CoreSysAttributes):
-    """Handle rest api for supervisor functions."""
+    """Handle RESTful API for Supervisor functions."""
 
     @api_process
     async def ping(self, request):
-        """Return ok for signal that the api is ready."""
+        """Return ok for signal that the API is ready."""
         return True
 
     @api_process
-    async def info(self, request):
+    async def info(self, request: web.Request) -> Dict[str, Any]:
         """Return host information."""
         list_addons = []
-        for addon in self.sys_addons.list_addons:
-            if addon.is_installed:
-                list_addons.append({
+        for addon in self.sys_addons.installed:
+            list_addons.append(
+                {
                     ATTR_NAME: addon.name,
                     ATTR_SLUG: addon.slug,
                     ATTR_DESCRIPTON: addon.description,
                     ATTR_STATE: await addon.state(),
-                    ATTR_VERSION: addon.last_version,
-                    ATTR_INSTALLED: addon.version_installed,
+                    ATTR_VERSION: addon.latest_version,
+                    ATTR_INSTALLED: addon.version,
                     ATTR_REPOSITORY: addon.repository,
                     ATTR_ICON: addon.with_icon,
                     ATTR_LOGO: addon.with_logo,
-                })
+                }
+            )
 
         return {
             ATTR_VERSION: HASSIO_VERSION,
             ATTR_LAST_VERSION: self.sys_updater.version_hassio,
             ATTR_CHANNEL: self.sys_updater.channel,
-            ATTR_ARCH: self.sys_arch,
+            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 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_CHANNEL in body:
@@ -80,20 +115,26 @@ class APISupervisor(CoreSysAttributes):
         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])
-            await asyncio.shield(self.sys_addons.load_repositories(new))
+            await asyncio.shield(self.sys_store.update_repositories(new))
 
         self.sys_updater.save_data()
         self.sys_config.save_data()
-        return True
 
     @api_process
-    async def stats(self, request):
+    async def stats(self, request: web.Request) -> Dict[str, Any]:
         """Return resource information."""
         stats = await self.sys_supervisor.stats()
-        if not stats:
-            raise RuntimeError("No stats available")
 
         return {
             ATTR_CPU_PERCENT: stats.cpu_percent,
@@ -106,33 +147,21 @@ class APISupervisor(CoreSysAttributes):
         }
 
     @api_process
-    async def update(self, request):
-        """Update supervisor OS."""
+    async def update(self, request: web.Request) -> None:
+        """Update Supervisor OS."""
         body = await api_validate(SCHEMA_VERSION, request)
         version = body.get(ATTR_VERSION, self.sys_updater.version_hassio)
 
         if version == self.sys_supervisor.version:
-            raise RuntimeError("Version {} is already in use".format(version))
-
-        return await asyncio.shield(
-            self.sys_supervisor.update(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 etc."""
-        tasks = [
-            self.sys_updater.reload(),
-        ]
-        results, _ = await asyncio.shield(
-            asyncio.wait(tasks))
-
-        for result in results:
-            if result.exception() is not None:
-                raise RuntimeError("Some reload task fails!")
-
-        return True
+    def reload(self, request: web.Request) -> Awaitable[None]:
+        """Reload add-ons, configuration, etc."""
+        return asyncio.shield(self.sys_updater.reload())
 
     @api_process_raw(CONTENT_TYPE_BINARY)
-    def logs(self, request):
-        """Return supervisor docker logs."""
+    def logs(self, request: web.Request) -> Awaitable[bytes]:
+        """Return supervisor Docker logs."""
         return self.sys_supervisor.logs()

hassio/api/utils.py

@@ -1,6 +1,5 @@
-"""Init file for HassIO util for rest api."""
+"""Init file for Hass.io util for RESTful API."""
 import json
-import hashlib
 import logging
 
 from aiohttp import web
@@ -10,7 +9,7 @@ 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
+from ..exceptions import HassioError, APIError, APIForbidden
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -22,19 +21,19 @@ def json_loads(data):
     try:
         return json.loads(data)
     except json.JSONDecodeError:
-        raise RuntimeError("Invalid json")
+        raise APIError("Invalid json")
 
 
 def api_process(method):
     """Wrap function with true/false calls to rest api."""
     async def wrap_api(api, *args, **kwargs):
-        """Return api information."""
+        """Return API information."""
         try:
             answer = await method(api, *args, **kwargs)
-        except RuntimeError as err:
+        except (APIError, APIForbidden) as err:
             return api_return_error(message=str(err))
         except HassioError:
-            return api_return_error()
+            return api_return_error(message="Unknown Error, see logs")
 
         if isinstance(answer, dict):
             return api_return_ok(data=answer)
@@ -56,7 +55,7 @@ def api_process_raw(content):
             try:
                 msg_data = await method(api, *args, **kwargs)
                 msg_type = content
-            except RuntimeError as err:
+            except (APIError, APIForbidden) as err:
                 msg_data = str(err).encode()
                 msg_type = CONTENT_TYPE_BINARY
             except HassioError:
@@ -91,12 +90,6 @@ async def api_validate(schema, request):
     try:
         data = schema(data)
     except vol.Invalid as ex:
-        raise RuntimeError(humanize_error(data, ex)) from None
+        raise APIError(humanize_error(data, ex)) from None
 
     return data
-
-
-def hash_password(password):
-    """Hash and salt our passwords."""
-    key = ")*()*SALT_HASSIO2123{}6554547485HSKA!!*JSLAfdasda$".format(password)
-    return hashlib.sha256(key.encode()).hexdigest()

hassio/arch.json

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