Improve D-Bus error handling for NetworkManager (#4720)

* Improve D-Bus error handling for NetworkManager

There are quite some errors captured which are related by seemingly a
suddenly missing NetworkManager. Errors appear as:
23-11-21 17:42:50 ERROR (MainThread) [supervisor.dbus.network] Error while processing /org/freedesktop/NetworkManager/Devices/10: Remote peer disconnected
...
23-11-21 17:42:50 ERROR (MainThread) [supervisor.dbus.network] Error while processing /org/freedesktop/NetworkManager/Devices/35: The name is not activatable

Both errors seem to already happen at introspection time, however
the current code doesn't converts these errors to Supervisor issues.
This PR uses the already existing `DBus.from_dbus_error()`.

Furthermore this adds a new Exception `DBusNoReplyError` for the
`ErrorType.NO_REPLY` (or `org.freedesktop.DBus.Error.NoReply` in
D-Bus terms, which is the type of the first of the two issues above).

And finally it separates the `ErrorType.SERVICE_UNKNOWN` (or
`org.freedesktop.DBus.Error.ServiceUnknown` in D-Bus terms, which is
the second of the above issue) from `DBusInterfaceError` into a new
`DBusServiceUnkownError`.

This allows to handle errors more specifically.

To avoid too much churn, all instances where `DBusInterfaceError`
got handled, we are now also handling `DBusServiceUnkownError`.

The `DBusNoReplyError` and `DBusServiceUnkownError` appear when
the NetworkManager service stops or crashes. Instead of retrying
every interface we know, just give up if one of these issues appear.
This should significantly lower error messages users are seeing
and Sentry events.

* Remove unnecessary statement

* Fix pytests

* Make sure error strings are compared correctly

* Fix typo/remove unnecessary pylint exception

* Fix DBusError typing

* Add pytest for from_dbus_error

* Revert "Make sure error strings are compared correctly"

This reverts commit 10dc2e4c3887532921414b4291fe3987186db408.

* Add test cases

---------

Co-authored-by: Mike Degatano <michael.degatano@gmail.com>

.devcontainer/Dockerfile

@@ -1,27 +0,0 @@
-FROM python:3.7
-
-WORKDIR /workspace
-
-# install Node/Yarn for Frontent
-RUN apt-get update && apt-get install -y --no-install-recommends \
-        curl \
-        git \
-        apt-utils \
-        apt-transport-https \
-    && curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | apt-key add - \
-    && echo "deb https://dl.yarnpkg.com/debian/ stable main" | tee /etc/apt/sources.list.d/yarn.list \
-    && apt-get update && apt-get install -y --no-install-recommends \
-        nodejs \
-        yarn \
-    && curl -o - https://raw.githubusercontent.com/creationix/nvm/v0.34.0/install.sh | bash \
-    && rm -rf /var/lib/apt/lists/*
-ENV NVM_DIR /root/.nvm
-
-# Install Python dependencies from requirements.txt if it exists
-COPY requirements.txt requirements_tests.txt /workspace/
-RUN pip install -r requirements.txt \
-    && pip3 install -r requirements_tests.txt \
-    && pip install black tox
-
-# Set the default shell to bash instead of sh
-ENV SHELL /bin/bash

.devcontainer/devcontainer.json

@@ -1,27 +1,38 @@
-// See https://aka.ms/vscode-remote/devcontainer.json for format details.
 {
-	"name": "Hass.io dev",
-	"context": "..",
-	"dockerFile": "Dockerfile",
-	"runArgs": [
-		"-e",
-		"GIT_EDTIOR='code --wait'"
-	],
-	"extensions": [
-		"ms-python.python"
-	],
-	"settings": {
-		"python.pythonPath": "/usr/local/bin/python",
-		"python.linting.pylintEnabled": true,
-		"python.linting.enabled": true,
-		"python.formatting.provider": "black",
-		"python.formatting.blackArgs": [
-			"--target-version",
-			"py37"
-		],
-		"editor.formatOnPaste": false,
-		"editor.formatOnSave": true,
-		"editor.formatOnType": true,
-		"files.trimTrailingWhitespace": true
-	}
+  "name": "Supervisor dev",
+  "image": "ghcr.io/home-assistant/devcontainer:supervisor",
+  "containerEnv": {
+    "WORKSPACE_DIRECTORY": "${containerWorkspaceFolder}"
+  },
+  "appPort": ["9123:8123", "7357:4357"],
+  "postCreateCommand": "bash devcontainer_bootstrap",
+  "runArgs": ["-e", "GIT_EDITOR=code --wait", "--privileged"],
+  "customizations": {
+    "vscode": {
+      "extensions": [
+        "ms-python.python",
+        "ms-python.pylint",
+        "ms-python.vscode-pylance",
+        "visualstudioexptteam.vscodeintellicode",
+        "esbenp.prettier-vscode"
+      ],
+      "settings": {
+        "terminal.integrated.profiles.linux": {
+          "zsh": {
+            "path": "/usr/bin/zsh"
+          }
+        },
+        "terminal.integrated.defaultProfile.linux": "zsh",
+        "editor.formatOnPaste": false,
+        "editor.formatOnSave": true,
+        "editor.formatOnType": true,
+        "files.trimTrailingWhitespace": true,
+        "python.pythonPath": "/usr/local/bin/python3",
+        "python.formatting.provider": "black",
+        "python.formatting.blackArgs": ["--target-version", "py311"],
+        "python.formatting.blackPath": "/usr/local/bin/black"
+      }
+    }
+  },
+  "mounts": ["type=volume,target=/var/lib/docker"]
 }

.dockerignore

@@ -14,7 +14,10 @@
 # virtualenv
 venv/
 
-# HA
-home-assistant-polymer/*
-misc/*
-script/*
+# Data
+home-assistant-polymer/
+script/
+tests/
+
+# Test ENV
+data/

.github/ISSUE_TEMPLATE.md

@@ -1,29 +1,69 @@
+---
+name: Report a bug with the Supervisor on a supported System
+about: Report an issue related to the Home Assistant Supervisor.
+labels: bug
+---
+
 <!-- 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.
+- If you have a problem with an add-on, make an issue in it's repository.
 -->
 
-**Home Assistant release with the issue:**
 <!--
-- Frontend -> Developer tools -> Info
-- Or use this command: hass --version
+Important: You can only fill a bug repport for an supported system! If you run an unsupported installation. This report would be closed without comment.
 -->
 
-**Operating environment (HassOS/Generic):**
+### Describe the issue
+
+<!-- Provide as many details as possible. -->
+
+### Steps to reproduce
+
+<!-- What do you do to encounter the issue. -->
+
+1. ...
+2. ...
+3. ...
+
+### Enviroment details
+
+<!-- You can find these details in the system tab of the supervisor panel, or by using the `ha` CLI. -->
+
+- **Operating System:**: xxx
+- **Supervisor version:**: xxx
+- **Home Assistant version**: xxx
+
+### Supervisor logs
+
+<details>
+<summary>Supervisor logs</summary>
 <!--
-Please provide details about your environment.
+- Frontend -> Supervisor -> System
+- Or use this command: ha supervisor logs
+- Logs are more than just errors, even if you don't think it's important, it is.
 -->
 
-**Supervisor logs:**
+```
+Paste supervisor logs here
+
+```
+
+</details>
+
+### System Information
+
+<details>
+<summary>System Information</summary>
 <!--
-- Frontend -> Hass.io -> System
-- Or use this command: hassio su logs
+- Use this command: ha info
 -->
 
+```
+Paste system info here
 
-**Description of problem:**
+```
+
+</details>
 

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,96 @@
+name: Bug Report Form
+description: Report an issue related to the Home Assistant Supervisor.
+labels: bug
+body:
+  - type: markdown
+    attributes:
+      value: |
+        This issue form is for reporting bugs with **supported** setups only!
+
+        If you have a feature or enhancement request, please use the [feature request][fr] section of our [Community Forum][fr].
+
+        [fr]: https://community.home-assistant.io/c/feature-requests
+  - type: textarea
+    validations:
+      required: true
+    attributes:
+      label: Describe the issue you are experiencing
+      description: Provide a clear and concise description of what the bug is.
+  - type: markdown
+    attributes:
+      value: |
+        ## Environment
+  - type: dropdown
+    validations:
+      required: true
+    attributes:
+      label: What type of installation are you running?
+      description: >
+        If you don't know, can be found in [Settings -> System -> Repairs -> System Information](https://my.home-assistant.io/redirect/system_health/).
+        It is listed as the `Installation Type` value.
+      options:
+        - Home Assistant OS
+        - Home Assistant Supervised
+  - type: dropdown
+    validations:
+      required: true
+    attributes:
+      label: Which operating system are you running on?
+      options:
+        - Home Assistant Operating System
+        - Debian
+        - Other (e.g., Raspbian/Raspberry Pi OS/Fedora)
+  - type: markdown
+    attributes:
+      value: |
+        # Details
+  - type: textarea
+    validations:
+      required: true
+    attributes:
+      label: Steps to reproduce the issue
+      description: |
+        Please tell us exactly how to reproduce your issue.
+        Provide clear and concise step by step instructions and add code snippets if needed.
+      value: |
+        1.
+        2.
+        3.
+        ...
+  - type: textarea
+    validations:
+      required: true
+    attributes:
+      label: Anything in the Supervisor logs that might be useful for us?
+      description: >
+        Supervisor Logs can be found in [Settings -> System -> Logs](https://my.home-assistant.io/redirect/logs/)
+        then choose `Supervisor` in the top right.
+
+        [![Open your Home Assistant instance and show your Supervisor system logs.](https://my.home-assistant.io/badges/supervisor_logs.svg)](https://my.home-assistant.io/redirect/supervisor_logs/)
+      render: txt
+  - type: textarea
+    validations:
+      required: true
+    attributes:
+      label: System Health information
+      description: >
+        System Health information can be found in the top right menu in [Settings -> System -> Repairs](https://my.home-assistant.io/redirect/repairs/).
+        Click the copy button at the bottom of the pop-up and paste it here.
+        
+        [![Open your Home Assistant instance and show health information about your system.](https://my.home-assistant.io/badges/system_health.svg)](https://my.home-assistant.io/redirect/system_health/)
+  - type: textarea
+    attributes:
+      label: Supervisor diagnostics
+      placeholder: "drag-and-drop the diagnostics data file here (do not copy-and-paste the content)"
+      description: >-
+        Supervisor diagnostics can be found in [Settings -> Integrations](https://my.home-assistant.io/redirect/integrations/).
+        Find the card that says `Home Assistant Supervisor`, open its menu and select 'Download diagnostics'.
+        
+        **Please drag-and-drop the downloaded file into the textbox below. Do not copy and paste its contents.**
+  - type: textarea
+    attributes:
+      label: Additional information
+      description: >
+        If you have any additional information for us, use the field below.
+        Please note, you can attach screenshots or screen recordings here, by
+        dragging and dropping files in the field below.

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,25 @@
+blank_issues_enabled: false
+contact_links:
+  - name: Report a bug/issues with an unsupported Supervisor
+    url: https://community.home-assistant.io
+    about: The Community guide can help or was updated to solve your issue
+
+  - name: Report a bug for the Supervisor panel
+    url: https://github.com/home-assistant/frontend/issues
+    about: The Supervisor panel is a part of the Home Assistant frontend
+
+  - name: Report incorrect or missing information on our developer documentation
+    url: https://github.com/home-assistant/developers.home-assistant.io/issues
+    about: Our documentation has its own issue tracker. Please report issues with the website there.
+
+  - name: Request a feature for the Supervisor
+    url: https://community.home-assistant.io/c/feature-requests
+    about: Request an new feature for the Supervisor.
+
+  - name: I have a question or need support
+    url: https://www.home-assistant.io/help
+    about: We use GitHub for tracking bugs, check our website for resources on getting help.
+
+  - name: I'm unsure where to go?
+    url: https://www.home-assistant.io/join-chat
+    about: If you are unsure where to go, then joining our chat is recommended; Just ask!

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,69 @@
+<!--
+  You are amazing! Thanks for contributing to our project!
+  Please, DO NOT DELETE ANY TEXT from this template! (unless instructed).
+-->
+
+## Proposed change
+
+<!--
+  Describe the big picture of your changes here to communicate to the
+  maintainers why we should accept this pull request. If it fixes a bug
+  or resolves a feature request, be sure to link to that issue in the
+  additional information section.
+-->
+
+## Type of change
+
+<!--
+  What type of change does your PR introduce to Home Assistant?
+  NOTE: Please, check only 1! box!
+  If your PR requires multiple boxes to be checked, you'll most likely need to
+  split it into multiple PRs. This makes things easier and faster to code review.
+-->
+
+- [ ] Dependency upgrade
+- [ ] Bugfix (non-breaking change which fixes an issue)
+- [ ] New feature (which adds functionality to the supervisor)
+- [ ] Breaking change (fix/feature causing existing functionality to break)
+- [ ] Code quality improvements to existing code or addition of tests
+
+## Additional information
+
+<!--
+  Details are important, and help maintainers processing your PR.
+  Please be sure to fill out additional details, if applicable.
+-->
+
+- This PR fixes or closes issue: fixes #
+- This PR is related to issue:
+- Link to documentation pull request:
+- Link to cli pull request:
+
+## Checklist
+
+<!--
+  Put an `x` in the boxes that apply. You can also fill these out after
+  creating the PR. If you're unsure about any of them, don't hesitate to ask.
+  We're here to help! This is simply a reminder of what we are going to look
+  for before merging your code.
+-->
+
+- [ ] The code change is tested and works locally.
+- [ ] Local tests pass. **Your PR cannot be merged unless tests pass**
+- [ ] There is no commented out code in this PR.
+- [ ] I have followed the [development checklist][dev-checklist]
+- [ ] The code has been formatted using Black (`black --fast supervisor tests`)
+- [ ] Tests have been added to verify that the new code works.
+
+If API endpoints of add-on configuration are added/changed:
+
+- [ ] Documentation added/updated for [developers.home-assistant.io][docs-repository]
+
+<!--
+  Thank you for contributing <3
+
+  Below, some useful links you could explore:
+-->
+
+[dev-checklist]: https://developers.home-assistant.io/docs/en/development_checklist.html
+[docs-repository]: https://github.com/home-assistant/developers.home-assistant

.github/dependabot.yml

@@ -0,0 +1,14 @@
+version: 2
+updates:
+- package-ecosystem: pip
+  directory: "/"
+  schedule:
+    interval: daily
+    time: "06:00"
+  open-pull-requests-limit: 10
+- package-ecosystem: "github-actions"
+  directory: "/"
+  schedule:
+    interval: daily
+    time: "06:00"
+  open-pull-requests-limit: 10

.github/release-drafter.yml

@@ -1,4 +1,50 @@
+change-template: "- #$NUMBER $TITLE @$AUTHOR"
+sort-direction: ascending
+
+categories:
+  - title: ":boom: Breaking Changes"
+    label: "breaking-change"
+
+  - title: ":wrench: Build"
+    label: "build"
+
+  - title: ":boar: Chore"
+    label: "chore"
+
+  - title: ":sparkles: New Features"
+    label: "new-feature"
+
+  - title: ":zap: Performance"
+    label: "performance"
+
+  - title: ":recycle: Refactor"
+    label: "refactor"
+
+  - title: ":green_heart: CI"
+    label: "ci"
+
+  - title: ":bug: Bug Fixes"
+    label: "bugfix"
+
+  - title: ":white_check_mark: Test"
+    label: "test"
+
+  - title: ":arrow_up: Dependency Updates"
+    label: "dependencies"
+    collapse-after: 1
+
+include-labels:
+  - "breaking-change"
+  - "build"
+  - "chore"
+  - "performance"
+  - "refactor"
+  - "new-feature"
+  - "bugfix"
+  - "dependencies"
+  - "test"
+  - "ci"
+
 template: |
-  ## What's Changed
 
   $CHANGES

.github/stale.yml

@@ -1,17 +0,0 @@
-# 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

.github/workflows/builder.yml

@@ -0,0 +1,380 @@
+name: Build supervisor
+
+on:
+  workflow_dispatch:
+    inputs:
+      channel:
+        description: "Channel"
+        required: true
+        default: "dev"
+      version:
+        description: "Version"
+        required: true
+      publish:
+        description: "Publish"
+        required: true
+        default: "false"
+      stable:
+        description: "Stable"
+        required: true
+        default: "false"
+  pull_request:
+    branches: ["main"]
+  release:
+    types: ["published"]
+  push:
+    branches: ["main"]
+    paths:
+      - "rootfs/**"
+      - "supervisor/**"
+      - build.yaml
+      - Dockerfile
+      - requirements.txt
+      - setup.py
+
+env:
+  DEFAULT_PYTHON: "3.11"
+  BUILD_NAME: supervisor
+  BUILD_TYPE: supervisor
+
+concurrency:
+  group: "${{ github.workflow }}-${{ github.ref }}"
+  cancel-in-progress: true
+
+jobs:
+  init:
+    name: Initialize build
+    runs-on: ubuntu-latest
+    outputs:
+      architectures: ${{ steps.info.outputs.architectures }}
+      version: ${{ steps.version.outputs.version }}
+      channel: ${{ steps.version.outputs.channel }}
+      publish: ${{ steps.version.outputs.publish }}
+      requirements: ${{ steps.requirements.outputs.changed }}
+    steps:
+      - name: Checkout the repository
+        uses: actions/checkout@v4.1.1
+        with:
+          fetch-depth: 0
+
+      - name: Get information
+        id: info
+        uses: home-assistant/actions/helpers/info@master
+
+      - name: Get version
+        id: version
+        uses: home-assistant/actions/helpers/version@master
+        with:
+          type: ${{ env.BUILD_TYPE }}
+
+      - name: Get changed files
+        id: changed_files
+        if: steps.version.outputs.publish == 'false'
+        uses: jitterbit/get-changed-files@v1
+
+      - name: Check if requirements files changed
+        id: requirements
+        run: |
+          if [[ "${{ steps.changed_files.outputs.all }}" =~ (requirements.txt|build.json) ]]; then
+            echo "::set-output name=changed::true"
+          fi
+
+  build:
+    name: Build ${{ matrix.arch }} supervisor
+    needs: init
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      id-token: write
+      packages: write
+    strategy:
+      matrix:
+        arch: ${{ fromJson(needs.init.outputs.architectures) }}
+    steps:
+      - name: Checkout the repository
+        uses: actions/checkout@v4.1.1
+        with:
+          fetch-depth: 0
+
+      - name: Write env-file
+        if: needs.init.outputs.requirements == 'true'
+        run: |
+          (
+            # Fix out of memory issues with rust
+            echo "CARGO_NET_GIT_FETCH_WITH_CLI=true"
+          ) > .env_file
+
+      - name: Build wheels
+        if: needs.init.outputs.requirements == 'true'
+        uses: home-assistant/wheels@2023.10.5
+        with:
+          abi: cp311
+          tag: musllinux_1_2
+          arch: ${{ matrix.arch }}
+          wheels-key: ${{ secrets.WHEELS_KEY }}
+          apk: "libffi-dev;openssl-dev;yaml-dev"
+          skip-binary: aiohttp
+          env-file: true
+          requirements: "requirements.txt"
+
+      - name: Set version
+        if: needs.init.outputs.publish == 'true'
+        uses: home-assistant/actions/helpers/version@master
+        with:
+          type: ${{ env.BUILD_TYPE }}
+
+      - name: Set up Python ${{ env.DEFAULT_PYTHON }}
+        if: needs.init.outputs.publish == 'true'
+        uses: actions/setup-python@v4.7.1
+        with:
+          python-version: ${{ env.DEFAULT_PYTHON }}
+
+      - name: Install Cosign
+        if: needs.init.outputs.publish == 'true'
+        uses: sigstore/cosign-installer@v3.2.0
+        with:
+          cosign-release: "v2.0.2"
+
+      - name: Install dirhash and calc hash
+        if: needs.init.outputs.publish == 'true'
+        run: |
+          pip3 install dirhash
+          dir_hash="$(dirhash "${{ github.workspace }}/supervisor" -a sha256 --match "*.py")"
+          echo "${dir_hash}" > rootfs/supervisor.sha256
+
+      - name: Sign supervisor SHA256
+        if: needs.init.outputs.publish == 'true'
+        run: |
+          cosign sign-blob --yes rootfs/supervisor.sha256 --bundle rootfs/supervisor.sha256.sig
+
+      - name: Login to GitHub Container Registry
+        if: needs.init.outputs.publish == 'true'
+        uses: docker/login-action@v3.0.0
+        with:
+          registry: ghcr.io
+          username: ${{ github.repository_owner }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Set build arguments
+        if: needs.init.outputs.publish == 'false'
+        run: echo "BUILD_ARGS=--test" >> $GITHUB_ENV
+
+      - name: Build supervisor
+        uses: home-assistant/builder@2023.09.0
+        with:
+          args: |
+            $BUILD_ARGS \
+            --${{ matrix.arch }} \
+            --target /data \
+            --cosign \
+            --generic ${{ needs.init.outputs.version }}
+        env:
+          CAS_API_KEY: ${{ secrets.CAS_TOKEN }}
+
+  version:
+    name: Update version
+    needs: ["init", "run_supervisor"]
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout the repository
+        if: needs.init.outputs.publish == 'true'
+        uses: actions/checkout@v4.1.1
+
+      - name: Initialize git
+        if: needs.init.outputs.publish == 'true'
+        uses: home-assistant/actions/helpers/git-init@master
+        with:
+          name: ${{ secrets.GIT_NAME }}
+          email: ${{ secrets.GIT_EMAIL }}
+          token: ${{ secrets.GIT_TOKEN }}
+
+      - name: Update version file
+        if: needs.init.outputs.publish == 'true'
+        uses: home-assistant/actions/helpers/version-push@master
+        with:
+          key: ${{ env.BUILD_NAME }}
+          version: ${{ needs.init.outputs.version }}
+          channel: ${{ needs.init.outputs.channel }}
+
+  run_supervisor:
+    runs-on: ubuntu-latest
+    name: Run the Supervisor
+    needs: ["build", "init"]
+    timeout-minutes: 60
+    steps:
+      - name: Checkout the repository
+        uses: actions/checkout@v4.1.1
+
+      - name: Build the Supervisor
+        if: needs.init.outputs.publish != 'true'
+        uses: home-assistant/builder@2023.09.0
+        with:
+          args: |
+            --test \
+            --amd64 \
+            --target /data \
+            --generic runner
+
+      - name: Pull Supervisor
+        if: needs.init.outputs.publish == 'true'
+        run: |
+          docker pull ghcr.io/home-assistant/amd64-hassio-supervisor:${{ needs.init.outputs.version }}
+          docker tag ghcr.io/home-assistant/amd64-hassio-supervisor:${{ needs.init.outputs.version }} ghcr.io/home-assistant/amd64-hassio-supervisor:runner
+
+      - name: Create the Supervisor
+        run: |
+          mkdir -p /tmp/supervisor/data
+          docker create --name hassio_supervisor \
+            --privileged \
+            --security-opt seccomp=unconfined \
+            --security-opt apparmor=unconfined \
+            -v /run/docker.sock:/run/docker.sock \
+            -v /run/dbus:/run/dbus \
+            -v /tmp/supervisor/data:/data \
+            -v /etc/machine-id:/etc/machine-id:ro \
+            -e SUPERVISOR_SHARE="/tmp/supervisor/data" \
+            -e SUPERVISOR_NAME=hassio_supervisor \
+            -e SUPERVISOR_DEV=1 \
+            -e SUPERVISOR_MACHINE="qemux86-64" \
+          ghcr.io/home-assistant/amd64-hassio-supervisor:runner
+
+      - name: Start the Supervisor
+        run: docker start hassio_supervisor
+
+      - name: Wait for Supervisor to come up
+        run: |
+          SUPERVISOR=$(docker inspect --format='{{.NetworkSettings.IPAddress}}' hassio_supervisor)
+          ping="error"
+          while [ "$ping" != "ok" ]; do
+            ping=$(curl -sSL "http://$SUPERVISOR/supervisor/ping" | jq -r '.result')
+            sleep 5
+          done
+
+      - name: Check the Supervisor
+        run: |
+          echo "Checking supervisor info"
+          test=$(docker exec hassio_cli ha supervisor info --no-progress --raw-json | jq -r '.result')
+          if [ "$test" != "ok" ]; then
+            exit 1
+          fi
+
+          echo "Checking supervisor network info"
+          test=$(docker exec hassio_cli ha network info --no-progress --raw-json | jq -r '.result')
+          if [ "$test" != "ok" ]; then
+            exit 1
+          fi
+
+      - name: Check the Store / Addon
+        run: |
+          echo "Install Core SSH Add-on"
+          test=$(docker exec hassio_cli ha addons install core_ssh --no-progress --raw-json | jq -r '.result')
+          if [ "$test" != "ok" ]; then
+            exit 1
+          fi
+
+          # Make sure it actually installed
+          test=$(docker exec hassio_cli ha addons info core_ssh --no-progress --raw-json | jq -r '.data.version')
+          if [[ "$test" == "null" ]]; then
+            exit 1
+          fi
+
+          echo "Start Core SSH Add-on"
+          test=$(docker exec hassio_cli ha addons start core_ssh --no-progress --raw-json | jq -r '.result')
+          if [ "$test" != "ok" ]; then
+            exit 1
+          fi
+
+          # Make sure its state is started
+          test="$(docker exec hassio_cli ha addons info core_ssh --no-progress --raw-json | jq -r '.data.state')"
+          if [ "$test" != "started" ]; then
+            exit 1
+          fi
+
+      - name: Check the Supervisor code sign
+        if: needs.init.outputs.publish == 'true'
+        run: |
+          echo "Enable Content-Trust"
+          test=$(docker exec hassio_cli ha security options --content-trust=true --no-progress --raw-json | jq -r '.result')
+          if [ "$test" != "ok" ]; then
+            exit 1
+          fi
+
+          echo "Run supervisor health check"
+          test=$(docker exec hassio_cli ha resolution healthcheck --no-progress --raw-json | jq -r '.result')
+          if [ "$test" != "ok" ]; then
+            exit 1
+          fi
+
+          echo "Check supervisor unhealthy"
+          test=$(docker exec hassio_cli ha resolution info --no-progress --raw-json | jq -r '.data.unhealthy[]')
+          if [ "$test" != "" ]; then
+            exit 1
+          fi
+
+          echo "Check supervisor supported"
+          test=$(docker exec hassio_cli ha resolution info --no-progress --raw-json | jq -r '.data.unsupported[]')
+          if [[ "$test" =~ source_mods ]]; then
+            exit 1
+          fi
+
+      - name: Create full backup
+        id: backup
+        run: |
+          test=$(docker exec hassio_cli ha backups new --no-progress --raw-json)
+          if [ "$(echo $test | jq -r '.result')" != "ok" ]; then
+            exit 1
+          fi
+          echo "::set-output name=slug::$(echo $test | jq -r '.data.slug')"
+
+      - name: Uninstall SSH add-on
+        run: |
+          test=$(docker exec hassio_cli ha addons uninstall core_ssh --no-progress --raw-json | jq -r '.result')
+          if [ "$test" != "ok" ]; then
+            exit 1
+          fi
+
+      - name: Restart supervisor
+        run: |
+          test=$(docker exec hassio_cli ha supervisor restart --no-progress --raw-json | jq -r '.result')
+          if [ "$test" != "ok" ]; then
+            exit 1
+          fi
+
+      - name: Wait for Supervisor to come up
+        run: |
+          SUPERVISOR=$(docker inspect --format='{{.NetworkSettings.IPAddress}}' hassio_supervisor)
+          ping="error"
+          while [ "$ping" != "ok" ]; do
+            ping=$(curl -sSL "http://$SUPERVISOR/supervisor/ping" | jq -r '.result')
+            sleep 5
+          done
+
+      - name: Restore SSH add-on from backup
+        run: |
+          test=$(docker exec hassio_cli ha backups restore ${{ steps.backup.outputs.slug }} --addons core_ssh --no-progress --raw-json | jq -r '.result')
+          if [ "$test" != "ok" ]; then
+            exit 1
+          fi
+
+          # Make sure it actually installed
+          test=$(docker exec hassio_cli ha addons info core_ssh --no-progress --raw-json | jq -r '.data.version')
+          if [[ "$test" == "null" ]]; then
+            exit 1
+          fi
+
+          # Make sure its state is started
+          test="$(docker exec hassio_cli ha addons info core_ssh --no-progress --raw-json | jq -r '.data.state')"
+          if [ "$test" != "started" ]; then
+            exit 1
+          fi
+
+      - name: Restore SSL directory from backup
+        run: |
+          test=$(docker exec hassio_cli ha backups restore ${{ steps.backup.outputs.slug }} --folders ssl --no-progress --raw-json | jq -r '.result')
+          if [ "$test" != "ok" ]; then
+            exit 1
+          fi
+
+      - name: Get supervisor logs on failiure
+        if: ${{ cancelled() || failure() }}
+        run: docker logs hassio_supervisor

.github/workflows/check_pr_labels.yml

@@ -0,0 +1,19 @@
+name: Check PR
+
+on:
+  pull_request:
+    branches: ["main"]
+    types: [labeled, unlabeled, synchronize]
+
+jobs:
+  init:
+    name: Check labels
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check labels
+        run: |
+          labels=$(jq -r '.pull_request.labels[] | .name' ${{github.event_path }})
+          echo "$labels"
+          if [ "$labels" == "cla-signed" ]; then
+            exit 1
+          fi

.github/workflows/ci.yaml

@@ -0,0 +1,432 @@
+name: CI
+
+# yamllint disable-line rule:truthy
+on:
+  push:
+    branches:
+      - main
+  pull_request: ~
+
+env:
+  DEFAULT_PYTHON: "3.11"
+  PRE_COMMIT_HOME: ~/.cache/pre-commit
+
+concurrency:
+  group: "${{ github.workflow }}-${{ github.ref }}"
+  cancel-in-progress: true
+
+jobs:
+  # Separate job to pre-populate the base dependency cache
+  # This prevent upcoming jobs to do the same individually
+  prepare:
+    runs-on: ubuntu-latest
+    outputs:
+      python-version: ${{ steps.python.outputs.python-version }}
+    name: Prepare Python dependencies
+    steps:
+      - name: Check out code from GitHub
+        uses: actions/checkout@v4.1.1
+      - name: Set up Python
+        id: python
+        uses: actions/setup-python@v4.7.1
+        with:
+          python-version: ${{ env.DEFAULT_PYTHON }}
+      - name: Restore Python virtual environment
+        id: cache-venv
+        uses: actions/cache@v3.3.2
+        with:
+          path: venv
+          key: |
+            ${{ runner.os }}-venv-${{ steps.python.outputs.python-version }}-${{ hashFiles('requirements.txt') }}-${{ hashFiles('requirements_tests.txt') }}
+      - name: Create Python virtual environment
+        if: steps.cache-venv.outputs.cache-hit != 'true'
+        run: |
+          python -m venv venv
+          . venv/bin/activate
+          pip install -U pip setuptools
+          pip install -r requirements.txt -r requirements_tests.txt
+      - name: Restore pre-commit environment from cache
+        id: cache-precommit
+        uses: actions/cache@v3.3.2
+        with:
+          path: ${{ env.PRE_COMMIT_HOME }}
+          key: |
+            ${{ runner.os }}-pre-commit-${{ hashFiles('.pre-commit-config.yaml') }}
+          restore-keys: |
+            ${{ runner.os }}-pre-commit-
+      - name: Install pre-commit dependencies
+        if: steps.cache-precommit.outputs.cache-hit != 'true'
+        run: |
+          . venv/bin/activate
+          pre-commit install-hooks
+
+  lint-black:
+    name: Check black
+    runs-on: ubuntu-latest
+    needs: prepare
+    steps:
+      - name: Check out code from GitHub
+        uses: actions/checkout@v4.1.1
+      - name: Set up Python ${{ needs.prepare.outputs.python-version }}
+        uses: actions/setup-python@v4.7.1
+        id: python
+        with:
+          python-version: ${{ needs.prepare.outputs.python-version }}
+      - name: Restore Python virtual environment
+        id: cache-venv
+        uses: actions/cache@v3.3.2
+        with:
+          path: venv
+          key: |
+            ${{ runner.os }}-venv-${{ needs.prepare.outputs.python-version }}-${{ hashFiles('requirements.txt') }}-${{ hashFiles('requirements_tests.txt') }}
+      - name: Fail job if Python cache restore failed
+        if: steps.cache-venv.outputs.cache-hit != 'true'
+        run: |
+          echo "Failed to restore Python virtual environment from cache"
+          exit 1
+      - name: Run black
+        run: |
+          . venv/bin/activate
+          black --target-version py311 --check supervisor tests setup.py
+
+  lint-dockerfile:
+    name: Check Dockerfile
+    runs-on: ubuntu-latest
+    needs: prepare
+    steps:
+      - name: Check out code from GitHub
+        uses: actions/checkout@v4.1.1
+      - name: Register hadolint problem matcher
+        run: |
+          echo "::add-matcher::.github/workflows/matchers/hadolint.json"
+      - name: Check Dockerfile
+        uses: docker://hadolint/hadolint:v1.18.0
+        with:
+          args: hadolint Dockerfile
+
+  lint-executable-shebangs:
+    name: Check executables
+    runs-on: ubuntu-latest
+    needs: prepare
+    steps:
+      - name: Check out code from GitHub
+        uses: actions/checkout@v4.1.1
+      - name: Set up Python ${{ needs.prepare.outputs.python-version }}
+        uses: actions/setup-python@v4.7.1
+        id: python
+        with:
+          python-version: ${{ needs.prepare.outputs.python-version }}
+      - name: Restore Python virtual environment
+        id: cache-venv
+        uses: actions/cache@v3.3.2
+        with:
+          path: venv
+          key: |
+            ${{ runner.os }}-venv-${{ needs.prepare.outputs.python-version }}-${{ hashFiles('requirements.txt') }}-${{ hashFiles('requirements_tests.txt') }}
+      - name: Fail job if Python cache restore failed
+        if: steps.cache-venv.outputs.cache-hit != 'true'
+        run: |
+          echo "Failed to restore Python virtual environment from cache"
+          exit 1
+      - name: Restore pre-commit environment from cache
+        id: cache-precommit
+        uses: actions/cache@v3.3.2
+        with:
+          path: ${{ env.PRE_COMMIT_HOME }}
+          key: |
+            ${{ runner.os }}-pre-commit-${{ hashFiles('.pre-commit-config.yaml') }}
+      - name: Fail job if cache restore failed
+        if: steps.cache-venv.outputs.cache-hit != 'true'
+        run: |
+          echo "Failed to restore Python virtual environment from cache"
+          exit 1
+      - name: Register check executables problem matcher
+        run: |
+          echo "::add-matcher::.github/workflows/matchers/check-executables-have-shebangs.json"
+      - name: Run executables check
+        run: |
+          . venv/bin/activate
+          pre-commit run --hook-stage manual check-executables-have-shebangs --all-files
+
+  lint-flake8:
+    name: Check flake8
+    runs-on: ubuntu-latest
+    needs: prepare
+    steps:
+      - name: Check out code from GitHub
+        uses: actions/checkout@v4.1.1
+      - name: Set up Python ${{ needs.prepare.outputs.python-version }}
+        uses: actions/setup-python@v4.7.1
+        id: python
+        with:
+          python-version: ${{ needs.prepare.outputs.python-version }}
+      - name: Restore Python virtual environment
+        id: cache-venv
+        uses: actions/cache@v3.3.2
+        with:
+          path: venv
+          key: |
+            ${{ runner.os }}-venv-${{ needs.prepare.outputs.python-version }}-${{ hashFiles('requirements.txt') }}-${{ hashFiles('requirements_tests.txt') }}
+      - name: Fail job if Python cache restore failed
+        if: steps.cache-venv.outputs.cache-hit != 'true'
+        run: |
+          echo "Failed to restore Python virtual environment from cache"
+          exit 1
+      - name: Register flake8 problem matcher
+        run: |
+          echo "::add-matcher::.github/workflows/matchers/flake8.json"
+      - name: Run flake8
+        run: |
+          . venv/bin/activate
+          flake8 supervisor tests
+
+  lint-isort:
+    name: Check isort
+    runs-on: ubuntu-latest
+    needs: prepare
+    steps:
+      - name: Check out code from GitHub
+        uses: actions/checkout@v4.1.1
+      - name: Set up Python ${{ needs.prepare.outputs.python-version }}
+        uses: actions/setup-python@v4.7.1
+        id: python
+        with:
+          python-version: ${{ needs.prepare.outputs.python-version }}
+      - name: Restore Python virtual environment
+        id: cache-venv
+        uses: actions/cache@v3.3.2
+        with:
+          path: venv
+          key: |
+            ${{ runner.os }}-venv-${{ needs.prepare.outputs.python-version }}-${{ hashFiles('requirements.txt') }}-${{ hashFiles('requirements_tests.txt') }}
+      - name: Fail job if Python cache restore failed
+        if: steps.cache-venv.outputs.cache-hit != 'true'
+        run: |
+          echo "Failed to restore Python virtual environment from cache"
+          exit 1
+      - name: Restore pre-commit environment from cache
+        id: cache-precommit
+        uses: actions/cache@v3.3.2
+        with:
+          path: ${{ env.PRE_COMMIT_HOME }}
+          key: |
+            ${{ runner.os }}-pre-commit-${{ hashFiles('.pre-commit-config.yaml') }}
+      - name: Fail job if cache restore failed
+        if: steps.cache-venv.outputs.cache-hit != 'true'
+        run: |
+          echo "Failed to restore Python virtual environment from cache"
+          exit 1
+      - name: Run isort
+        run: |
+          . venv/bin/activate
+          pre-commit run --hook-stage manual isort --all-files --show-diff-on-failure
+
+  lint-json:
+    name: Check JSON
+    runs-on: ubuntu-latest
+    needs: prepare
+    steps:
+      - name: Check out code from GitHub
+        uses: actions/checkout@v4.1.1
+      - name: Set up Python ${{ needs.prepare.outputs.python-version }}
+        uses: actions/setup-python@v4.7.1
+        id: python
+        with:
+          python-version: ${{ needs.prepare.outputs.python-version }}
+      - name: Restore Python virtual environment
+        id: cache-venv
+        uses: actions/cache@v3.3.2
+        with:
+          path: venv
+          key: |
+            ${{ runner.os }}-venv-${{ needs.prepare.outputs.python-version }}-${{ hashFiles('requirements.txt') }}-${{ hashFiles('requirements_tests.txt') }}
+      - name: Fail job if Python cache restore failed
+        if: steps.cache-venv.outputs.cache-hit != 'true'
+        run: |
+          echo "Failed to restore Python virtual environment from cache"
+          exit 1
+      - name: Restore pre-commit environment from cache
+        id: cache-precommit
+        uses: actions/cache@v3.3.2
+        with:
+          path: ${{ env.PRE_COMMIT_HOME }}
+          key: |
+            ${{ runner.os }}-pre-commit-${{ hashFiles('.pre-commit-config.yaml') }}
+      - name: Fail job if cache restore failed
+        if: steps.cache-venv.outputs.cache-hit != 'true'
+        run: |
+          echo "Failed to restore Python virtual environment from cache"
+          exit 1
+      - name: Register check-json problem matcher
+        run: |
+          echo "::add-matcher::.github/workflows/matchers/check-json.json"
+      - name: Run check-json
+        run: |
+          . venv/bin/activate
+          pre-commit run --hook-stage manual check-json --all-files
+
+  lint-pylint:
+    name: Check pylint
+    runs-on: ubuntu-latest
+    needs: prepare
+    steps:
+      - name: Check out code from GitHub
+        uses: actions/checkout@v4.1.1
+      - name: Set up Python ${{ needs.prepare.outputs.python-version }}
+        uses: actions/setup-python@v4.7.1
+        id: python
+        with:
+          python-version: ${{ needs.prepare.outputs.python-version }}
+      - name: Restore Python virtual environment
+        id: cache-venv
+        uses: actions/cache@v3.3.2
+        with:
+          path: venv
+          key: |
+            ${{ runner.os }}-venv-${{ needs.prepare.outputs.python-version }}-${{ hashFiles('requirements.txt') }}-${{ hashFiles('requirements_tests.txt') }}
+      - name: Fail job if Python cache restore failed
+        if: steps.cache-venv.outputs.cache-hit != 'true'
+        run: |
+          echo "Failed to restore Python virtual environment from cache"
+          exit 1
+      - name: Register pylint problem matcher
+        run: |
+          echo "::add-matcher::.github/workflows/matchers/pylint.json"
+      - name: Run pylint
+        run: |
+          . venv/bin/activate
+          pylint supervisor tests
+
+  lint-pyupgrade:
+    name: Check pyupgrade
+    runs-on: ubuntu-latest
+    needs: prepare
+    steps:
+      - name: Check out code from GitHub
+        uses: actions/checkout@v4.1.1
+      - name: Set up Python ${{ needs.prepare.outputs.python-version }}
+        uses: actions/setup-python@v4.7.1
+        id: python
+        with:
+          python-version: ${{ needs.prepare.outputs.python-version }}
+      - name: Restore Python virtual environment
+        id: cache-venv
+        uses: actions/cache@v3.3.2
+        with:
+          path: venv
+          key: |
+            ${{ runner.os }}-venv-${{ needs.prepare.outputs.python-version }}-${{ hashFiles('requirements.txt') }}-${{ hashFiles('requirements_tests.txt') }}
+      - name: Fail job if Python cache restore failed
+        if: steps.cache-venv.outputs.cache-hit != 'true'
+        run: |
+          echo "Failed to restore Python virtual environment from cache"
+          exit 1
+      - name: Restore pre-commit environment from cache
+        id: cache-precommit
+        uses: actions/cache@v3.3.2
+        with:
+          path: ${{ env.PRE_COMMIT_HOME }}
+          key: |
+            ${{ runner.os }}-pre-commit-${{ hashFiles('.pre-commit-config.yaml') }}
+      - name: Fail job if cache restore failed
+        if: steps.cache-venv.outputs.cache-hit != 'true'
+        run: |
+          echo "Failed to restore Python virtual environment from cache"
+          exit 1
+      - name: Run pyupgrade
+        run: |
+          . venv/bin/activate
+          pre-commit run --hook-stage manual pyupgrade --all-files --show-diff-on-failure
+
+  pytest:
+    runs-on: ubuntu-latest
+    needs: prepare
+    name: Run tests Python ${{ needs.prepare.outputs.python-version }}
+    steps:
+      - name: Check out code from GitHub
+        uses: actions/checkout@v4.1.1
+      - name: Set up Python ${{ needs.prepare.outputs.python-version }}
+        uses: actions/setup-python@v4.7.1
+        id: python
+        with:
+          python-version: ${{ needs.prepare.outputs.python-version }}
+      - name: Install Cosign
+        uses: sigstore/cosign-installer@v3.2.0
+        with:
+          cosign-release: "v2.0.2"
+      - name: Restore Python virtual environment
+        id: cache-venv
+        uses: actions/cache@v3.3.2
+        with:
+          path: venv
+          key: |
+            ${{ runner.os }}-venv-${{ needs.prepare.outputs.python-version }}-${{ hashFiles('requirements.txt') }}-${{ hashFiles('requirements_tests.txt') }}
+      - name: Fail job if Python cache restore failed
+        if: steps.cache-venv.outputs.cache-hit != 'true'
+        run: |
+          echo "Failed to restore Python virtual environment from cache"
+          exit 1
+      - name: Install additional system dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y --no-install-recommends libpulse0 libudev1 dbus dbus-x11
+      - name: Register Python problem matcher
+        run: |
+          echo "::add-matcher::.github/workflows/matchers/python.json"
+      - name: Install Pytest Annotation plugin
+        run: |
+          . venv/bin/activate
+          # Ideally this should be part of our dependencies
+          # However this plugin is fairly new and doesn't run correctly
+          # on a non-GitHub environment.
+          pip install pytest-github-actions-annotate-failures
+      - name: Run pytest
+        run: |
+          . venv/bin/activate
+          pytest \
+            -qq \
+            --timeout=10 \
+            --durations=10 \
+            --cov supervisor \
+            -o console_output_style=count \
+            tests
+      - name: Upload coverage artifact
+        uses: actions/upload-artifact@v3.1.3
+        with:
+          name: coverage-${{ matrix.python-version }}
+          path: .coverage
+
+  coverage:
+    name: Process test coverage
+    runs-on: ubuntu-latest
+    needs: ["pytest", "prepare"]
+    steps:
+      - name: Check out code from GitHub
+        uses: actions/checkout@v4.1.1
+      - name: Set up Python ${{ needs.prepare.outputs.python-version }}
+        uses: actions/setup-python@v4.7.1
+        id: python
+        with:
+          python-version: ${{ needs.prepare.outputs.python-version }}
+      - name: Restore Python virtual environment
+        id: cache-venv
+        uses: actions/cache@v3.3.2
+        with:
+          path: venv
+          key: |
+            ${{ runner.os }}-venv-${{ needs.prepare.outputs.python-version }}-${{ hashFiles('requirements.txt') }}-${{ hashFiles('requirements_tests.txt') }}
+      - name: Fail job if Python cache restore failed
+        if: steps.cache-venv.outputs.cache-hit != 'true'
+        run: |
+          echo "Failed to restore Python virtual environment from cache"
+          exit 1
+      - name: Download all coverage artifacts
+        uses: actions/download-artifact@v3
+      - name: Combine coverage results
+        run: |
+          . venv/bin/activate
+          coverage combine coverage*/.coverage*
+          coverage report
+          coverage xml
+      - name: Upload coverage to Codecov
+        uses: codecov/codecov-action@v3.1.4

.github/workflows/lock.yml

@@ -0,0 +1,20 @@
+name: Lock
+
+# yamllint disable-line rule:truthy
+on:
+  schedule:
+    - cron: "0 0 * * *"
+
+jobs:
+  lock:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: dessant/lock-threads@v5.0.1
+        with:
+          github-token: ${{ github.token }}
+          issue-inactive-days: "30"
+          exclude-issue-created-before: "2020-10-01T00:00:00Z"
+          issue-lock-reason: ""
+          pr-inactive-days: "1"
+          exclude-pr-created-before: "2020-11-01T00:00:00Z"
+          pr-lock-reason: ""

.github/workflows/matchers/check-executables-have-shebangs.json

@@ -0,0 +1,14 @@
+{
+  "problemMatcher": [
+    {
+      "owner": "check-executables-have-shebangs",
+      "pattern": [
+        {
+          "regexp": "^(.+):\\s(.+)$",
+          "file": 1,
+          "message": 2
+        }
+      ]
+    }
+  ]
+}

.github/workflows/matchers/check-json.json

@@ -0,0 +1,16 @@
+{
+  "problemMatcher": [
+    {
+      "owner": "check-json",
+      "pattern": [
+        {
+          "regexp": "^(.+):\\s(.+\\sline\\s(\\d+)\\scolumn\\s(\\d+).+)$",
+          "file": 1,
+          "message": 2,
+          "line": 3,
+          "column": 4
+        }
+      ]
+    }
+  ]
+}

.github/workflows/matchers/flake8.json

@@ -0,0 +1,30 @@
+{
+  "problemMatcher": [
+    {
+      "owner": "flake8-error",
+      "severity": "error",
+      "pattern": [
+        {
+          "regexp": "^(.*):(\\d+):(\\d+):\\s(E\\d{3}\\s.*)$",
+          "file": 1,
+          "line": 2,
+          "column": 3,
+          "message": 4
+        }
+      ]
+    },
+    {
+      "owner": "flake8-warning",
+      "severity": "warning",
+      "pattern": [
+        {
+          "regexp": "^(.*):(\\d+):(\\d+):\\s([CDFNW]\\d{3}\\s.*)$",
+          "file": 1,
+          "line": 2,
+          "column": 3,
+          "message": 4
+        }
+      ]
+    }
+  ]
+}

.github/workflows/matchers/hadolint.json

@@ -0,0 +1,16 @@
+{
+  "problemMatcher": [
+    {
+      "owner": "hadolint",
+      "pattern": [
+        {
+          "regexp": "^(.+):(\\d+)\\s+((DL\\d{4}).+)$",
+          "file": 1,
+          "line": 2,
+          "message": 3,
+          "code": 4
+        }
+      ]
+    }
+  ]
+}

.github/workflows/matchers/pylint.json

@@ -0,0 +1,32 @@
+{
+  "problemMatcher": [
+    {
+      "owner": "pylint-error",
+      "severity": "error",
+      "pattern": [
+        {
+          "regexp": "^(.+):(\\d+):(\\d+):\\s(([EF]\\d{4}):\\s.+)$",
+          "file": 1,
+          "line": 2,
+          "column": 3,
+          "message": 4,
+          "code": 5
+        }
+      ]
+    },
+    {
+      "owner": "pylint-warning",
+      "severity": "warning",
+      "pattern": [
+        {
+          "regexp": "^(.+):(\\d+):(\\d+):\\s(([CRW]\\d{4}):\\s.+)$",
+          "file": 1,
+          "line": 2,
+          "column": 3,
+          "message": 4,
+          "code": 5
+        }
+      ]
+    }
+  ]
+}

.github/workflows/matchers/python.json

@@ -0,0 +1,18 @@
+{
+  "problemMatcher": [
+    {
+      "owner": "python",
+      "pattern": [
+        {
+          "regexp": "^\\s*File\\s\\\"(.*)\\\",\\sline\\s(\\d+),\\sin\\s(.*)$",
+          "file": 1,
+          "line": 2
+        },
+        {
+          "regexp": "^\\s*raise\\s(.*)\\(\\'(.*)\\'\\)$",
+          "message": 2
+        }
+      ]
+    }
+  ]
+}

.github/workflows/release-drafter.yml

@@ -0,0 +1,44 @@
+name: Release Drafter
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  update_release_draft:
+    runs-on: ubuntu-latest
+    name: Release Drafter
+    steps:
+      - name: Checkout the repository
+        uses: actions/checkout@v4.1.1
+        with:
+          fetch-depth: 0
+
+      - name: Find Next Version
+        id: version
+        run: |
+          declare -i newpost
+          latest=$(git describe --tags $(git rev-list --tags --max-count=1))
+          latestpre=$(echo "$latest" | awk '{split($0,a,"."); print a[1] "." a[2]}')
+          datepre=$(date --utc '+%Y.%m')
+
+
+          if [[ "$latestpre" == "$datepre" ]]; then
+              latestpost=$(echo "$latest" | awk '{split($0,a,"."); print a[3]}')
+              newpost=$latestpost+1
+          else
+              newpost=0
+          fi
+
+          echo Current version:    $latest
+          echo New target version: $datepre.$newpost
+          echo "::set-output name=version::$datepre.$newpost"
+
+      - name: Run Release Drafter
+        uses: release-drafter/release-drafter@v5.25.0
+        with:
+          tag: ${{ steps.version.outputs.version }}
+          name: ${{ steps.version.outputs.version }}
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/sentry.yaml

@@ -0,0 +1,21 @@
+name: Sentry Release
+
+# yamllint disable-line rule:truthy
+on:
+  release:
+    types: [published, prereleased]
+
+jobs:
+  createSentryRelease:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out code from GitHub
+        uses: actions/checkout@v4.1.1
+      - name: Sentry Release
+        uses: getsentry/action-release@v1.4.1
+        env:
+          SENTRY_AUTH_TOKEN: ${{ secrets.SENTRY_AUTH_TOKEN }}
+          SENTRY_ORG: ${{ secrets.SENTRY_ORG }}
+          SENTRY_PROJECT: ${{ secrets.SENTRY_PROJECT }}
+        with:
+          environment: production

.github/workflows/stale.yml

@@ -0,0 +1,39 @@
+name: Stale
+
+# yamllint disable-line rule:truthy
+on:
+  schedule:
+    - cron: "0 * * * *"
+
+jobs:
+  stale:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/stale@v8.0.0
+        with:
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+          days-before-stale: 30
+          days-before-close: 7
+          stale-issue-label: "stale"
+          exempt-issue-labels: "no-stale,Help%20wanted,help-wanted,pinned,rfc,security"
+          stale-issue-message: >
+            There hasn't been any activity on this issue recently. Due to the
+            high number of incoming GitHub notifications, we have to clean some
+            of the old issues, as many of them have already been resolved with
+            the latest updates.
+
+            Please make sure to update to the latest version and check if that
+            solves the issue. Let us know if that works for you by
+            adding a comment 👍
+
+            This issue has now been marked as stale and will be closed if no
+            further activity occurs. Thank you for your contributions.
+
+          stale-pr-label: "stale"
+          exempt-pr-labels: "no-stale,pinned,rfc,security"
+          stale-pr-message: >
+            There hasn't been any activity on this pull request recently. This
+            pull request has been automatically marked as stale because of that
+            and will be closed if no further activity occurs within 7 days.
+
+            Thank you for your contributions.

.gitignore

@@ -95,3 +95,8 @@ ENV/
 .vscode/*
 !.vscode/cSpell.json
 !.vscode/tasks.json
+!.vscode/launch.json
+
+# mypy
+/.mypy_cache/*
+/.dmypy.json

.hadolint.yaml

@@ -1,5 +1,7 @@
 ignored:
-  - DL3018
+  - DL3003
   - DL3006
   - DL3013
+  - DL3018
+  - DL3042
   - SC2155

.pre-commit-config.yaml

@@ -0,0 +1,34 @@
+repos:
+  - repo: https://github.com/psf/black
+    rev: 23.1.0
+    hooks:
+      - id: black
+        args:
+          - --safe
+          - --quiet
+          - --target-version
+          - py311
+        files: ^((supervisor|tests)/.+)?[^/]+\.py$
+  - repo: https://github.com/PyCQA/flake8
+    rev: 6.0.0
+    hooks:
+      - id: flake8
+        additional_dependencies:
+          - flake8-docstrings==1.7.0
+          - pydocstyle==6.3.0
+        files: ^(supervisor|script|tests)/.+\.py$
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.3.0
+    hooks:
+      - id: check-executables-have-shebangs
+        stages: [manual]
+      - id: check-json
+  - repo: https://github.com/PyCQA/isort
+    rev: 5.12.0
+    hooks:
+      - id: isort
+  - repo: https://github.com/asottile/pyupgrade
+    rev: v3.15.0
+    hooks:
+      - id: pyupgrade
+        args: [--py311-plus]

.vcnignore

@@ -0,0 +1,21 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Distribution / packaging
+*.egg-info/
+
+# General files
+.git
+.github
+.devcontainer
+.vscode
+.tox
+
+# Data
+home-assistant-polymer/
+script/
+tests/
+data/
+venv/

.vscode/launch.json

@@ -0,0 +1,25 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "Supervisor remote debug",
+      "type": "python",
+      "request": "attach",
+      "port": 33333,
+      "host": "172.30.32.2",
+      "pathMappings": [
+        {
+          "localRoot": "${workspaceFolder}",
+          "remoteRoot": "/usr/src/supervisor"
+        }
+      ]
+    },
+    {
+      "name": "Debug Tests",
+      "type": "python",
+      "request": "test",
+      "console": "internalConsole",
+      "justMyCode": false
+    }
+  ]
+}

.vscode/tasks.json

@@ -1,19 +1,97 @@
 {
-    "version": "2.0.0",
-    "tasks": [
-        {
-            "label": "Update UI",
-            "type": "shell",
-            "command": "./script/update-frontend.sh",
-            "group": {
-                "kind": "build",
-                "isDefault": true
-            },
-            "presentation": {
-                "reveal": "always",
-                "panel": "new"
-            },
-            "problemMatcher": []
-        }
-    ]
-}
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "label": "Run Supervisor",
+      "type": "shell",
+      "command": "supervisor_run",
+      "group": {
+        "kind": "test",
+        "isDefault": true
+      },
+      "presentation": {
+        "reveal": "always",
+        "panel": "new"
+      },
+      "problemMatcher": []
+    },
+    {
+      "label": "Run Supervisor CLI",
+      "type": "shell",
+      "command": "docker exec -ti hassio_cli /usr/bin/cli.sh",
+      "group": {
+        "kind": "test",
+        "isDefault": true
+      },
+      "presentation": {
+        "reveal": "always",
+        "panel": "new"
+      },
+      "problemMatcher": []
+    },
+    {
+      "label": "Update Supervisor Panel",
+      "type": "shell",
+      "command": "LOKALISE_TOKEN='${input:localiseToken}' ./scripts/update-frontend.sh",
+      "group": {
+        "kind": "build",
+        "isDefault": true
+      },
+      "presentation": {
+        "reveal": "always",
+        "panel": "new"
+      },
+      "problemMatcher": []
+    },
+    {
+      "label": "Pytest",
+      "type": "shell",
+      "command": "pytest --timeout=10 tests",
+      "group": {
+        "kind": "test",
+        "isDefault": true
+      },
+      "presentation": {
+        "reveal": "always",
+        "panel": "new"
+      },
+      "problemMatcher": []
+    },
+    {
+      "label": "Flake8",
+      "type": "shell",
+      "command": "flake8 supervisor tests",
+      "group": {
+        "kind": "test",
+        "isDefault": true
+      },
+      "presentation": {
+        "reveal": "always",
+        "panel": "new"
+      },
+      "problemMatcher": []
+    },
+    {
+      "label": "Pylint",
+      "type": "shell",
+      "command": "pylint supervisor",
+      "dependsOn": ["Install all Requirements"],
+      "group": {
+        "kind": "test",
+        "isDefault": true
+      },
+      "presentation": {
+        "reveal": "always",
+        "panel": "new"
+      },
+      "problemMatcher": []
+    }
+  ],
+  "inputs": [
+    {
+      "id": "localiseToken",
+      "type": "promptString",
+      "description": "Paste your lokalise token to download frontend translations"
+    }
+  ]
+}

API.md

@@ -1,752 +0,0 @@
-# Hass.io
-
-## Hass.io RESTful API
-
-Interface for Home Assistant to control things from supervisor.
-
-On error / Code 400:
-
-```json
-{
-    "result": "error",
-    "message": ""
-}
-```
-
-On success / Code 200:
-
-```json
-{
-    "result": "ok",
-    "data": { }
-}
-```
-
-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.
-
-```json
-{
-    "version": "INSTALL_VERSION",
-    "last_version": "LAST_VERSION",
-    "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",
-            "slug": "xy",
-            "description": "description",
-            "repository": "12345678|null",
-            "version": "LAST_VERSION",
-            "installed": "INSTALL_VERSION",
-            "icon": "bool",
-            "logo": "bool",
-            "state": "started|stopped",
-        }
-    ],
-    "addons_repositories": [
-        "REPO_URL"
-    ]
-}
-```
-
-- POST `/supervisor/update`
-
-Optional:
-
-```json
-{
-    "version": "VERSION"
-}
-```
-
-- POST `/supervisor/options`
-
-```json
-{
-    "channel": "stable|beta|dev",
-    "timezone": "TIMEZONE",
-    "wait_boot": "int",
-    "debug": "bool",
-    "debug_block": "bool",
-    "logging": "debug|info|warning|error|critical",
-    "addons_repositories": [
-        "REPO_URL"
-    ]
-}
-```
-
-- POST `/supervisor/reload`
-
-Reload addons/version.
-
-- GET `/supervisor/logs`
-
-Output is the raw docker log.
-
-- GET `/supervisor/stats`
-```json
-{
-    "cpu_percent": 0.0,
-    "memory_usage": 283123,
-    "memory_limit": 329392,
-    "network_tx": 0,
-    "network_rx": 0,
-    "blk_read": 0,
-    "blk_write": 0
-}
-```
-
-- GET `/supervisor/repair`
-
-Repair overlayfs issue and restore lost images
-
-### Snapshot
-
-- GET `/snapshots`
-
-```json
-{
-    "snapshots": [
-        {
-            "slug": "SLUG",
-            "date": "ISO",
-            "name": "Custom name",
-            "type": "full|partial",
-            "protected": "bool"
-        }
-    ]
-}
-```
-
-- POST `/snapshots/reload`
-
-- POST `/snapshots/new/upload`
-
-return:
-```json
-{
-    "slug": ""
-}
-```
-
-- POST `/snapshots/new/full`
-
-```json
-{
-    "name": "Optional",
-    "password": "Optional"
-}
-```
-
-return:
-```json
-{
-    "slug": ""
-}
-```
-
-- POST `/snapshots/new/partial`
-
-```json
-{
-    "name": "Optional",
-    "addons": ["ADDON_SLUG"],
-    "folders": ["FOLDER_NAME"],
-    "password": "Optional"
-}
-```
-
-return:
-```json
-{
-    "slug": ""
-}
-```
-
-- POST `/snapshots/reload`
-
-- GET `/snapshots/{slug}/info`
-
-```json
-{
-    "slug": "SNAPSHOT ID",
-    "type": "full|partial",
-    "name": "custom snapshot name / description",
-    "date": "ISO",
-    "size": "SIZE_IN_MB",
-    "protected": "bool",
-    "homeassistant": "version",
-    "addons": [
-        {
-            "slug": "ADDON_SLUG",
-            "name": "NAME",
-            "version": "INSTALLED_VERSION",
-            "size": "SIZE_IN_MB"
-        }
-    ],
-    "repositories": ["URL"],
-    "folders": ["NAME"]
-}
-```
-
-- POST `/snapshots/{slug}/remove`
-
-- GET `/snapshots/{slug}/download`
-
-- POST `/snapshots/{slug}/restore/full`
-
-```json
-{
-    "password": "Optional"
-}
-```
-
-- POST `/snapshots/{slug}/restore/partial`
-
-```json
-{
-    "homeassistant": "bool",
-    "addons": ["ADDON_SLUG"],
-    "folders": ["FOLDER_NAME"],
-    "password": "Optional"
-}
-```
-
-### Host
-
-- POST `/host/reload`
-
-- POST `/host/shutdown`
-
-- POST `/host/reboot`
-
-- GET `/host/info`
-
-```json
-{
-    "hostname": "hostname|null",
-    "features": ["shutdown", "reboot", "hostname", "services", "hassos"],
-    "operating_system": "HassOS XY|Ubuntu 16.4|null",
-    "kernel": "4.15.7|null",
-    "chassis": "specific|null",
-    "deployment": "stable|beta|dev|null",
-    "cpe": "xy|null",
-}
-```
-
-- POST `/host/options`
-
-```json
-{
-    "hostname": "",
-}
-```
-
-- POST `/host/reload`
-
-#### Services
-
-- GET `/host/services`
-```json
-{
-    "services": [
-        {
-            "name": "xy.service",
-            "description": "XY ...",
-            "state": "active|"
-        }
-    ]
-}
-```
-
-- POST `/host/service/{unit}/stop`
-
-- POST `/host/service/{unit}/start`
-
-- POST `/host/service/{unit}/reload`
-
-### HassOS
-
-- GET `/hassos/info`
-```json
-{
-    "version": "2.3",
-    "version_cli": "7",
-    "version_latest": "2.4",
-    "version_cli_latest": "8",
-    "board": "ova|rpi"
-}
-```
-
-- POST `/hassos/update`
-```json
-{
-    "version": "optional"
-}
-```
-
-- POST `/hassos/update/cli`
-```json
-{
-    "version": "optional"
-}
-```
-
-- POST `/hassos/config/sync`
-
-Load host configs from a USB stick.
-
-### Hardware
-
-- GET `/hardware/info`
-```json
-{
-    "serial": ["/dev/xy"],
-    "input": ["Input device name"],
-    "disk": ["/dev/sdax"],
-    "gpio": ["gpiochip0", "gpiochip100"],
-    "audio": {
-        "CARD_ID": {
-            "name": "xy",
-            "type": "microphone",
-            "devices": [
-                "chan_id": "channel ID",
-                "chan_type": "type of device"
-            ]
-        }
-    }
-}
-```
-
-- GET `/hardware/audio`
-```json
-{
-    "audio": {
-        "input": {
-            "0,0": "Mic"
-        },
-        "output": {
-            "1,0": "Jack",
-            "1,1": "HDMI"
-        }
-    }
-}
-```
-
-### Home Assistant
-
-- GET `/homeassistant/info`
-
-```json
-{
-    "version": "INSTALL_VERSION",
-    "last_version": "LAST_VERSION",
-    "arch": "arch",
-    "machine": "Image machine type",
-    "ip_address": "ip address",
-    "image": "str",
-    "custom": "bool -> if custom image",
-    "boot": "bool",
-    "port": 8123,
-    "ssl": "bool",
-    "watchdog": "bool",
-    "wait_boot": 600
-}
-```
-
-- POST `/homeassistant/update`
-
-Optional:
-
-```json
-{
-    "version": "VERSION"
-}
-```
-
-- GET `/homeassistant/logs`
-
-Output is the raw Docker log.
-
-- POST `/homeassistant/restart`
-- POST `/homeassistant/check`
-- POST `/homeassistant/start`
-- POST `/homeassistant/stop`
-- POST `/homeassistant/rebuild`
-
-- POST `/homeassistant/options`
-
-```json
-{
-    "image": "Optional|null",
-    "last_version": "Optional for custom image|null",
-    "port": "port for access hass",
-    "ssl": "bool",
-    "password": "",
-    "refresh_token": "",
-    "watchdog": "bool",
-    "wait_boot": 600
-}
-```
-
-Image with `null` and last_version with `null` reset this options.
-
-- POST/GET `/homeassistant/api`
-
-Proxy to real home-assistant instance.
-
-- GET `/homeassistant/websocket`
-
-Proxy to real websocket instance.
-
-- GET `/homeassistant/stats`
-```json
-{
-    "cpu_percent": 0.0,
-    "memory_usage": 283123,
-    "memory_limit": 329392,
-    "network_tx": 0,
-    "network_rx": 0,
-    "blk_read": 0,
-    "blk_write": 0
-}
-```
-
-### RESTful for API addons
-
-If an add-on will call itself, you can use `/addons/self/...`.
-
-- GET `/addons`
-
-Get all available addons.
-
-```json
-{
-    "addons": [
-        {
-            "name": "xy bla",
-            "slug": "xy",
-            "description": "description",
-            "repository": "core|local|REP_ID",
-            "version": "LAST_VERSION",
-            "installed": "none|INSTALL_VERSION",
-            "detached": "bool",
-            "available": "bool",
-            "build": "bool",
-            "url": "null|url",
-            "icon": "bool",
-            "logo": "bool"
-        }
-    ],
-    "repositories": [
-        {
-            "slug": "12345678",
-            "name": "Repitory Name|unknown",
-            "source": "URL_OF_REPOSITORY",
-            "url": "WEBSITE|REPOSITORY",
-            "maintainer": "BLA BLU <fla@dld.ch>|unknown"
-        }
-    ]
-}
-```
-
-- POST `/addons/reload`
-- GET `/addons/{addon}/info`
-
-```json
-{
-    "name": "xy bla",
-    "slug": "xdssd_xybla",
-    "description": "description",
-    "long_description": "null|markdown",
-    "auto_update": "bool",
-    "url": "null|url of addon",
-    "detached": "bool",
-    "available": "bool",
-    "arch": ["armhf", "aarch64", "i386", "amd64"],
-    "machine": "[raspberrypi2, tinker]",
-    "homeassistant": "null|min Home Assistant version",
-    "repository": "12345678|null",
-    "version": "null|VERSION_INSTALLED",
-    "last_version": "LAST_VERSION",
-    "state": "none|started|stopped",
-    "boot": "auto|manual",
-    "build": "bool",
-    "options": "{}",
-    "network": "{}|null",
-    "network_description": "{}|null",
-    "host_network": "bool",
-    "host_pid": "bool",
-    "host_ipc": "bool",
-    "host_dbus": "bool",
-    "privileged": ["NET_ADMIN", "SYS_ADMIN"],
-    "apparmor": "disable|default|profile",
-    "devices": ["/dev/xy"],
-    "auto_uart": "bool",
-    "icon": "bool",
-    "logo": "bool",
-    "changelog": "bool",
-    "hassio_api": "bool",
-    "hassio_role": "default|homeassistant|manager|admin",
-    "homeassistant_api": "bool",
-    "auth_api": "bool",
-    "full_access": "bool",
-    "protected": "bool",
-    "rating": "1-6",
-    "stdin": "bool",
-    "webui": "null|http(s)://[HOST]:port/xy/zx",
-    "gpio": "bool",
-    "kernel_modules": "bool",
-    "devicetree": "bool",
-    "docker_api": "bool",
-    "audio": "bool",
-    "audio_input": "null|0,0",
-    "audio_output": "null|0,0",
-    "services_role": "['service:access']",
-    "discovery": "['service']",
-    "ip_address": "ip address",
-    "ingress": "bool",
-    "ingress_entry": "null|/api/hassio_ingress/slug",
-    "ingress_url": "null|/api/hassio_ingress/slug/entry.html",
-    "ingress_port": "null|int",
-    "ingress_panel": "null|bool"
-}
-```
-
-- GET `/addons/{addon}/icon`
-
-- GET `/addons/{addon}/logo`
-
-- GET `/addons/{addon}/changelog`
-
-- POST `/addons/{addon}/options`
-
-```json
-{
-    "boot": "auto|manual",
-    "auto_update": "bool",
-    "network": {
-      "CONTAINER": "port|[ip, port]"
-    },
-    "options": {},
-    "audio_output": "null|0,0",
-    "audio_input": "null|0,0",
-    "ingress_panel": "bool"
-}
-```
-
-Reset custom network/audio/options, set it `null`.
-
-- POST `/addons/{addon}/security`
-
-This function is not callable by itself.
-
-```json
-{
-    "protected": "bool",
-}
-```
-
-- POST `/addons/{addon}/start`
-
-- POST `/addons/{addon}/stop`
-
-- POST `/addons/{addon}/install`
-
-- POST `/addons/{addon}/uninstall`
-
-- POST `/addons/{addon}/update`
-
-- GET `/addons/{addon}/logs`
-
-Output is the raw Docker log.
-
-- POST `/addons/{addon}/restart`
-
-- POST `/addons/{addon}/rebuild`
-
-Only supported for local build addons
-
-- POST `/addons/{addon}/stdin`
-
-Write data to add-on stdin
-
-- GET `/addons/{addon}/stats`
-```json
-{
-    "cpu_percent": 0.0,
-    "memory_usage": 283123,
-    "memory_limit": 329392,
-    "network_tx": 0,
-    "network_rx": 0,
-    "blk_read": 0,
-    "blk_write": 0
-}
-```
-
-### ingress
-
-- POST `/ingress/session`
-
-Create a new Session for access to ingress service.
-
-```json
-{
-    "session": "token"
-}
-```
-
-- GET `/ingress/panels`
-
-Return a list of enabled panels.
-
-```json
-{
-    "panels": {
-        "addon_slug": {
-            "enable": "boolean",
-            "icon": "mdi:...",
-            "title": "title",
-            "admin": "boolean"
-        }
-    }
-}
-```
-
-- VIEW `/ingress/{token}`
-
-Ingress WebUI for this Add-on. The addon need support HASS Auth!
-Need ingress session as cookie.
-
-### discovery
-
-- GET `/discovery`
-```json
-{
-    "discovery": [
-        {
-            "addon": "slug",
-            "service": "name",
-            "uuid": "uuid",
-            "config": {}
-        }
-    ]
-}
-```
-
-- GET `/discovery/{UUID}`
-```json
-{
-    "addon": "slug",
-    "service": "name",
-    "uuid": "uuid",
-    "config": {}
-}
-```
-
-- POST `/discovery`
-```json
-{
-    "service": "name",
-    "config": {}
-}
-```
-
-return:
-```json
-{
-    "uuid": "uuid"
-}
-```
-
-- DEL `/discovery/{UUID}`
-
-### Services
-
-- GET `/services`
-```json
-{
-    "services": [
-        {
-            "slug": "name",
-            "available": "bool",
-            "providers": "list"
-        }
-    ]
-}
-```
-
-#### MQTT
-
-- GET `/services/mqtt`
-```json
-{
-    "addon": "name",
-    "host": "xy",
-    "port": "8883",
-    "ssl": "bool",
-    "username": "optional",
-    "password": "optional",
-    "protocol": "3.1.1"
-}
-```
-
-- POST `/services/mqtt`
-```json
-{
-    "host": "xy",
-    "port": "8883",
-    "ssl": "bool|optional",
-    "username": "optional",
-    "password": "optional",
-    "protocol": "3.1.1"
-}
-```
-
-- DEL `/services/mqtt`
-
-### Misc
-
-- GET `/info`
-```json
-{
-    "supervisor": "version",
-    "homeassistant": "version",
-    "hassos": "null|version",
-    "hostname": "name",
-    "machine": "type",
-    "arch": "arch",
-    "supported_arch": ["arch1", "arch2"],
-    "channel": "stable|beta|dev",
-    "logging": "debug|info|warning|error|critical",
-    "timezone": "Europe/Zurich"
-}
-```
-
-### 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,38 +1,47 @@
 ARG BUILD_FROM
-FROM $BUILD_FROM
+FROM ${BUILD_FROM}
+
+ENV \
+    S6_SERVICES_GRACETIME=10000 \
+    SUPERVISOR_API=http://localhost \
+    CRYPTOGRAPHY_OPENSSL_NO_LEGACY=1
+
+ARG \
+    COSIGN_VERSION \
+    BUILD_ARCH
 
 # Install base
-RUN apk add --no-cache \
-    openssl \
-    libffi \
-    musl \
-    git \
-    socat \
-    glib \
-    libstdc++ \
-    eudev \
-    eudev-libs
-
-ARG BUILD_ARCH
 WORKDIR /usr/src
+RUN \
+    set -x \
+    && apk add --no-cache \
+        findutils \
+        eudev \
+        eudev-libs \
+        git \
+        libffi \
+        libpulse \
+        musl \
+        openssl \
+        yaml \
+    \
+    && curl -Lso /usr/bin/cosign "https://github.com/home-assistant/cosign/releases/download/${COSIGN_VERSION}/cosign_${BUILD_ARCH}" \
+    && chmod a+x /usr/bin/cosign
 
 # Install requirements
 COPY requirements.txt .
-RUN export MAKEFLAGS="-j$(nproc)" \
-    && pip3 install --no-cache-dir --no-index --only-binary=:all: --find-links \
-        "https://wheels.home-assistant.io/alpine-$(cut -d '.' -f 1-2 < /etc/alpine-release)/${BUILD_ARCH}/" \
+RUN \
+    export MAKEFLAGS="-j$(nproc)" \
+    && pip3 install --only-binary=:all: \
         -r ./requirements.txt \
     && rm -f requirements.txt
 
-# Install HassIO
-COPY . hassio
-RUN pip3 install --no-cache-dir -e ./hassio \
-    && python3 -m compileall ./hassio/hassio
+# Install Home Assistant Supervisor
+COPY . supervisor
+RUN \
+    pip3 install -e ./supervisor \
+    && python3 -m compileall ./supervisor/supervisor
 
 
-# Initialize udev daemon, handle CMD
-COPY entry.sh /bin/
-ENTRYPOINT ["/bin/entry.sh"]
-
 WORKDIR /
-CMD [ "python3", "-m", "hassio" ]
+COPY rootfs /

LICENSE

@@ -178,7 +178,7 @@
    APPENDIX: How to apply the Apache License to your work.
 
       To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "{}"
+      boilerplate notice, with the fields enclosed by brackets "[]"
       replaced with your own identifying information. (Don't include
       the brackets!)  The text should be enclosed in the appropriate
       comment syntax for the file format. We also recommend that a
@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright 2017 Pascal Vizeli
+   Copyright [yyyy] [name of copyright owner]
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

MANIFEST.in

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

README.md

@@ -1,30 +1,32 @@
-[![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
+# Home Assistant Supervisor
 
 ## First private cloud solution for home automation
 
-Hass.io is a Docker-based system for managing your Home Assistant installation
-and related applications. The system is controlled via Home Assistant which
-communicates with the Supervisor. The Supervisor provides an API to manage the
-installation. This includes changing network settings or installing
-and updating software.
-
-![](misc/hassio.png?raw=true)
+Home Assistant (former Hass.io) is a container-based system for managing your
+Home Assistant Core installation and related applications. The system is
+controlled via Home Assistant which communicates with the Supervisor. The
+Supervisor provides an API to manage the installation. This includes changing
+network settings or installing and updating software.
 
 ## Installation
 
-Installation instructions can be found at <https://home-assistant.io/hassio>.
+Installation instructions can be found at https://home-assistant.io/getting-started.
 
 ## Development
 
-The development of the supervisor is a bit tricky. Not difficult but tricky.
+For small changes and bugfixes you can just follow this, but for significant changes open a RFC first.
+Development instructions can be found [here][development].
 
-- 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
+## Release
 
-Small Bugfix or improvements, make a PR. Significant change makes first an RFC.
+Releases are done in 3 stages (channels) with this structure:
+
+1. Pull requests are merged to the `main` branch.
+2. A new build is pushed to the `dev` stage.
+3. Releases are published.
+4. A new build is pushed to the `beta` stage.
+5. The [`stable.json`][stable] file is updated.
+6. The build that was pushed to `beta` will now be pushed to `stable`.
+
+[development]: https://developers.home-assistant.io/docs/supervisor/development
+[stable]: https://github.com/home-assistant/version/blob/master/stable.json

azure-pipelines.yml

@@ -1,168 +0,0 @@
-# https://dev.azure.com/home-assistant
-
-trigger:
-  batch: true
-  branches:
-    include:
-    - master
-    - dev
-  tags:
-    include:
-    - '*'
-    exclude:
-    - untagged*
-pr:
-  - dev
-variables:
-  - name: basePythonTag
-    value: '3.7-alpine3.10'
-  - name: versionHadolint
-    value: 'v1.16.3'
-  - name: versionBuilder
-    value: '4.4'
-  - name: versionWheels
-    value: '1.0-3.7-alpine3.10'
-  - group: docker
-  - group: wheels
-
-
-stages:
-
-- stage: 'Test'
-  jobs:
-  - job: 'Tox'
-    pool:
-      vmImage: 'ubuntu-latest'
-    steps:
-    - task: UsePythonVersion@0
-      displayName: 'Use Python 3.7'
-      inputs:
-        versionSpec: '3.7'
-    - script: pip install tox
-      displayName: 'Install Tox'
-    - script: tox
-      displayName: 'Run Tox'
-  - job: 'Black'
-    pool:
-      vmImage: 'ubuntu-latest'
-    steps:
-    - task: UsePythonVersion@0
-      displayName: 'Use Python $(python.version)'
-      inputs:
-        versionSpec: '3.7'
-    - script: pip install black
-      displayName: 'Install black'
-    - script: black --target-version py37 --check hassio tests
-      displayName: 'Run Black'
-  - job: 'JQ'
-    pool:
-      vmImage: 'ubuntu-latest'
-    steps:
-    - script: sudo apt-get install -y jq
-      displayName: 'Install JQ'
-    - bash: |
-        shopt -s globstar
-        cat **/*.json | jq '.'
-      displayName: 'Run JQ'
-  - job: 'Hadolint'
-    pool:
-      vmImage: 'ubuntu-latest'
-    steps:
-    - script: sudo docker pull hadolint/hadolint:$(versionHadolint)
-      displayName: 'Install Hadolint'
-    - script: |
-        sudo docker run --rm -i \
-          -v $(pwd)/.hadolint.yaml:/.hadolint.yaml:ro \
-          hadolint/hadolint:$(versionHadolint) < Dockerfile
-      displayName: 'Run Hadolint'
-
-- stage: 'Wheels'
-  jobs:
-  - job: 'Wheels'
-    condition: eq(variables['Build.SourceBranchName'], 'dev')
-    timeoutInMinutes: 360
-    pool:
-      vmImage: 'ubuntu-latest'
-    strategy:
-      maxParallel: 5
-      matrix:
-        amd64:
-          buildArch: 'amd64'
-        i386:
-          buildArch: 'i386'
-        armhf:
-          buildArch: 'armhf'
-        armv7:
-          buildArch: 'armv7'
-        aarch64:
-          buildArch: 'aarch64'
-    steps:
-    - script: |
-        sudo apt-get update
-        sudo apt-get install -y --no-install-recommends \
-          qemu-user-static \
-          binfmt-support \
-          curl
-
-        sudo mount binfmt_misc -t binfmt_misc /proc/sys/fs/binfmt_misc
-        sudo update-binfmts --enable qemu-arm
-        sudo update-binfmts --enable qemu-aarch64
-      displayName: 'Initial cross build'
-    - script: |
-        mkdir -p .ssh
-        echo -e "-----BEGIN RSA PRIVATE KEY-----\n$(wheelsSSH)\n-----END RSA PRIVATE KEY-----" >> .ssh/id_rsa
-        ssh-keyscan -H $(wheelsHost) >> .ssh/known_hosts
-        chmod 600 .ssh/*
-      displayName: 'Install ssh key'
-    - script: sudo docker pull homeassistant/$(buildArch)-wheels:$(versionWheels)
-      displayName: 'Install wheels builder'
-    - script: |
-        sudo docker run --rm -v $(pwd):/data:ro -v $(pwd)/.ssh:/root/.ssh:rw \
-          homeassistant/$(buildArch)-wheels:$(versionWheels) \
-          --apk "build-base;libffi-dev;openssl-dev" \
-          --index $(wheelsIndex) \
-          --requirement requirements.txt \
-          --upload rsync \
-          --remote wheels@$(wheelsHost):/opt/wheels
-      displayName: 'Run wheels build'
-
-- stage: 'Deploy'
-  jobs:
-  - job: 'VersionValidate'
-    condition: or(startsWith(variables['Build.SourceBranch'], 'refs/tags'), eq(variables['Build.SourceBranchName'], 'dev'))
-    pool:
-      vmImage: 'ubuntu-latest'
-    steps:
-    - task: UsePythonVersion@0
-      displayName: 'Use Python 3.7'
-      inputs:
-        versionSpec: '3.7'
-    - script: |
-        setup_version="$(python setup.py -V)"
-        branch_version="$(Build.SourceBranchName)"
-
-        if [ "${branch_version}" == "dev" ]; then
-          exit 0
-        elif [ "${setup_version}" != "${branch_version}" ]; then
-          echo "Version of tag ${branch_version} don't match with ${setup_version}!"
-          exit 1
-        fi
-      displayName: 'Check version of branch/tag'
-  - job: 'Release'
-    dependsOn:
-    - 'VersionValidate'
-    pool:
-      vmImage: 'ubuntu-latest'
-    steps:
-    - script: sudo docker login -u $(dockerUser) -p $(dockerPassword)
-      displayName: 'Docker hub login'
-    - script: sudo docker pull homeassistant/amd64-builder:$(versionBuilder)
-      displayName: 'Install Builder'
-    - script: |
-        sudo docker run --rm --privileged \
-          -v ~/.docker:/root/.docker \
-          -v /run/docker.sock:/run/docker.sock:rw -v $(pwd):/data:ro \
-          homeassistant/amd64-builder:$(versionBuilder) \
-          --supervisor $(basePythonTag) --version $(Build.SourceBranchName) \
-          --all -t /data --docker-hub homeassistant
-      displayName: 'Build Release'

build.yaml

@@ -0,0 +1,24 @@
+image: ghcr.io/home-assistant/{arch}-hassio-supervisor
+build_from:
+  aarch64: ghcr.io/home-assistant/aarch64-base-python:3.11-alpine3.18
+  armhf: ghcr.io/home-assistant/armhf-base-python:3.11-alpine3.18
+  armv7: ghcr.io/home-assistant/armv7-base-python:3.11-alpine3.18
+  amd64: ghcr.io/home-assistant/amd64-base-python:3.11-alpine3.18
+  i386: ghcr.io/home-assistant/i386-base-python:3.11-alpine3.18
+codenotary:
+  signer: notary@home-assistant.io
+  base_image: notary@home-assistant.io
+cosign:
+  base_identity: https://github.com/home-assistant/docker-base/.*
+  identity: https://github.com/home-assistant/supervisor/.*
+args:
+  COSIGN_VERSION: 2.0.2
+labels:
+  io.hass.type: supervisor
+  org.opencontainers.image.title: Home Assistant Supervisor
+  org.opencontainers.image.description: Container-based system for managing Home Assistant Core installation
+  org.opencontainers.image.source: https://github.com/home-assistant/supervisor
+  org.opencontainers.image.authors: The Home Assistant Authors
+  org.opencontainers.image.url: https://www.home-assistant.io/
+  org.opencontainers.image.documentation: https://www.home-assistant.io/docs/
+  org.opencontainers.image.licenses: Apache License 2.0

codecov.yaml

@@ -0,0 +1,11 @@
+codecov:
+  branch: dev
+coverage:
+  status:
+    project:
+      default:
+        target: 40
+        threshold: 0.09
+comment: false
+github_checks:
+    annotations: false

entry.sh

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

hassio/__init__.py

@@ -1 +0,0 @@
-"""Init file for Hass.io."""

hassio/__main__.py

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

hassio/addons/__init__.py

@@ -1,293 +0,0 @@
-"""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 .data import AddonsData
-
-_LOGGER = logging.getLogger(__name__)
-
-AnyAddon = Union[Addon, AddonStore]
-
-
-class AddonManager(CoreSysAttributes):
-    """Manage add-ons inside Hass.io."""
-
-    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 all(self) -> List[AnyAddon]:
-        """Return a list of all add-ons."""
-        addons = {**self.store, **self.local}
-        return list(addons.values())
-
-    @property
-    def installed(self) -> List[Addon]:
-        """Return a list of all installed add-ons."""
-        return list(self.local.values())
-
-    def get(self, addon_slug: str) -> Optional[AnyAddon]:
-        """Return an add-on from 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_token(self, token: str) -> Optional[Addon]:
-        """Return an add-on from Hass.io token."""
-        for addon in self.installed:
-            if token == addon.hassio_token:
-                return addon
-        return None
-
-    async def load(self) -> None:
-        """Start up add-on management."""
-        tasks = []
-        for slug in self.data.system:
-            addon = self.local[slug] = Addon(self.coresys, slug)
-            tasks.append(addon.load())
-
-        # Run initial tasks
-        _LOGGER.info("Found %d installed add-ons", len(tasks))
-        if tasks:
-            await asyncio.wait(tasks)
-
-    async def boot(self, stage: str) -> None:
-        """Boot add-ons with mode auto."""
-        tasks = []
-        for addon in self.installed:
-            if addon.boot != BOOT_AUTO or addon.startup != stage:
-                continue
-            tasks.append(addon.start())
-
-        _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: str) -> None:
-        """Shutdown addons."""
-        tasks = []
-        for addon in self.installed:
-            if await addon.state() != STATE_STARTED or addon.startup != stage:
-                continue
-            tasks.append(addon.stop())
-
-        _LOGGER.info("Phase '%s' stop %d add-ons", stage, len(tasks))
-        if tasks:
-            await asyncio.wait(tasks)
-
-    async def install(self, slug: str) -> None:
-        """Install an add-on."""
-        if slug in self.local:
-            _LOGGER.warning("Add-on %s is already installed", slug)
-            return
-        store = self.store.get(slug)
-
-        if not store:
-            _LOGGER.error("Add-on %s not exists", slug)
-            raise AddonsError()
-
-        if not store.available:
-            _LOGGER.error("Add-on %s not supported on that platform", slug)
-            raise AddonsNotSupportedError()
-
-        self.data.install(store)
-        addon = Addon(self.coresys, slug)
-
-        if not addon.path_data.is_dir():
-            _LOGGER.info("Create Home Assistant add-on data folder %s", addon.path_data)
-            addon.path_data.mkdir()
-
-        # Setup/Fix AppArmor profile
-        await addon.install_apparmor()
-
-        try:
-            await addon.instance.install(store.version, store.image)
-        except DockerAPIError:
-            self.data.uninstall(addon)
-            raise AddonsError() from None
-        else:
-            self.local[slug] = addon
-            _LOGGER.info("Add-on '%s' successfully installed", slug)
-
-    async def uninstall(self, slug: str) -> None:
-        """Remove an add-on."""
-        if slug not in self.local:
-            _LOGGER.warning("Add-on %s is not installed", slug)
-            return
-        addon = self.local.get(slug)
-
-        try:
-            await addon.instance.remove()
-        except DockerAPIError:
-            raise AddonsError() from None
-
-        await addon.remove_data()
-
-        # Cleanup audio settings
-        if addon.path_asound.exists():
-            with suppress(OSError):
-                addon.path_asound.unlink()
-
-        # Cleanup AppArmor profile
-        with suppress(HostAppArmorError):
-            await addon.uninstall_apparmor()
-
-        # Cleanup internal data
-        addon.remove_discovery()
-        self.data.uninstall(addon)
-        self.local.pop(slug)
-
-        _LOGGER.info("Add-on '%s' successfully removed", slug)
-
-    async def update(self, slug: str) -> None:
-        """Update add-on."""
-        if slug not in self.local:
-            _LOGGER.error("Add-on %s is not installed", slug)
-            raise AddonsError()
-        addon = self.local.get(slug)
-
-        if addon.is_detached:
-            _LOGGER.error("Add-on %s is not available inside store", slug)
-            raise AddonsError()
-        store = self.store.get(slug)
-
-        if addon.version == store.version:
-            _LOGGER.warning("No update available for add-on %s", slug)
-            return
-
-        # 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)
-
-            # Cleanup
-            with suppress(DockerAPIError):
-                await addon.instance.cleanup()
-        except DockerAPIError:
-            raise AddonsError() from None
-        else:
-            self.data.update(store)
-            _LOGGER.info("Add-on '%s' successfully updated", slug)
-
-        # 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)
-            _LOGGER.info("Add-on '%s' successfully rebuilded", slug)
-
-        # 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
-
-    async def repair(self) -> None:
-        """Repair local add-ons."""
-        needs_repair: List[Addon] = []
-
-        # Evaluate Add-ons to repair
-        for addon in self.installed:
-            if await addon.instance.exists():
-                continue
-            needs_repair.append(addon)
-
-        _LOGGER.info("Found %d add-ons to repair", len(needs_repair))
-        if not needs_repair:
-            return
-
-        for addon in needs_repair:
-            _LOGGER.info("Start repair for add-on: %s", addon.slug)
-
-            with suppress(DockerAPIError, KeyError):
-                # Need pull a image again
-                if not addon.need_build:
-                    await addon.instance.install(addon.version, addon.image)
-                    continue
-
-                # Need local lookup
-                elif addon.need_build and not addon.is_detached:
-                    store = self.store[addon.slug]
-                    # If this add-on is available for rebuild
-                    if addon.version == store.version:
-                        await addon.instance.install(addon.version, addon.image)
-                        continue
-
-            _LOGGER.error("Can't repair %s", addon.slug)
-            with suppress(AddonsError):
-                await self.uninstall(addon.slug)

hassio/addons/addon.py

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

hassio/addons/build.py

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

hassio/addons/validate.py

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

hassio/api/__init__.py

@@ -1,295 +0,0 @@
-"""Init file for Hass.io RESTful API."""
-import logging
-from pathlib import Path
-from typing import Optional
-
-from aiohttp import web
-
-from ..coresys import CoreSys, CoreSysAttributes
-from .addons import APIAddons
-from .auth import APIAuth
-from .discovery import APIDiscovery
-from .hardware import APIHardware
-from .hassos import APIHassOS
-from .homeassistant import APIHomeAssistant
-from .host import APIHost
-from .info import APIInfo
-from .ingress import APIIngress
-from .proxy import APIProxy
-from .security import SecurityMiddleware
-from .services import APIServices
-from .snapshots import APISnapshots
-from .supervisor import APISupervisor
-
-_LOGGER = logging.getLogger(__name__)
-
-
-class RestAPI(CoreSysAttributes):
-    """Handle RESTful API for Hass.io."""
-
-    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 = web.AppRunner(self.webapp)
-        self._site: Optional[web.TCPSite] = None
-
-    async def load(self) -> None:
-        """Register REST API Calls."""
-        self._register_supervisor()
-        self._register_host()
-        self._register_hassos()
-        self._register_hardware()
-        self._register_homeassistant()
-        self._register_proxy()
-        self._register_panel()
-        self._register_addons()
-        self._register_ingress()
-        self._register_snapshots()
-        self._register_discovery()
-        self._register_services()
-        self._register_info()
-        self._register_auth()
-
-    def _register_host(self) -> None:
-        """Register hostcontrol functions."""
-        api_host = APIHost()
-        api_host.coresys = self.coresys
-
-        self.webapp.add_routes(
-            [
-                web.get("/host/info", api_host.info),
-                web.post("/host/reboot", api_host.reboot),
-                web.post("/host/shutdown", api_host.shutdown),
-                web.post("/host/reload", api_host.reload),
-                web.post("/host/options", api_host.options),
-                web.get("/host/services", api_host.services),
-                web.post("/host/services/{service}/stop", api_host.service_stop),
-                web.post("/host/services/{service}/start", api_host.service_start),
-                web.post("/host/services/{service}/restart", api_host.service_restart),
-                web.post("/host/services/{service}/reload", api_host.service_reload),
-            ]
-        )
-
-    def _register_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) -> None:
-        """Register hardware functions."""
-        api_hardware = APIHardware()
-        api_hardware.coresys = self.coresys
-
-        self.webapp.add_routes(
-            [
-                web.get("/hardware/info", api_hardware.info),
-                web.get("/hardware/audio", api_hardware.audio),
-            ]
-        )
-
-    def _register_info(self) -> None:
-        """Register info functions."""
-        api_info = APIInfo()
-        api_info.coresys = self.coresys
-
-        self.webapp.add_routes([web.get("/info", api_info.info)])
-
-    def _register_auth(self) -> None:
-        """Register auth functions."""
-        api_auth = APIAuth()
-        api_auth.coresys = self.coresys
-
-        self.webapp.add_routes([web.post("/auth", api_auth.auth)])
-
-    def _register_supervisor(self) -> None:
-        """Register Supervisor functions."""
-        api_supervisor = APISupervisor()
-        api_supervisor.coresys = self.coresys
-
-        self.webapp.add_routes(
-            [
-                web.get("/supervisor/ping", api_supervisor.ping),
-                web.get("/supervisor/info", api_supervisor.info),
-                web.get("/supervisor/stats", api_supervisor.stats),
-                web.get("/supervisor/logs", api_supervisor.logs),
-                web.post("/supervisor/update", api_supervisor.update),
-                web.post("/supervisor/reload", api_supervisor.reload),
-                web.post("/supervisor/options", api_supervisor.options),
-                web.post("/supervisor/repair", api_supervisor.repair),
-            ]
-        )
-
-    def _register_homeassistant(self) -> None:
-        """Register Home Assistant functions."""
-        api_hass = APIHomeAssistant()
-        api_hass.coresys = self.coresys
-
-        self.webapp.add_routes(
-            [
-                web.get("/homeassistant/info", api_hass.info),
-                web.get("/homeassistant/logs", api_hass.logs),
-                web.get("/homeassistant/stats", api_hass.stats),
-                web.post("/homeassistant/options", api_hass.options),
-                web.post("/homeassistant/update", api_hass.update),
-                web.post("/homeassistant/restart", api_hass.restart),
-                web.post("/homeassistant/stop", api_hass.stop),
-                web.post("/homeassistant/start", api_hass.start),
-                web.post("/homeassistant/check", api_hass.check),
-                web.post("/homeassistant/rebuild", api_hass.rebuild),
-            ]
-        )
-
-    def _register_proxy(self) -> None:
-        """Register Home Assistant API Proxy."""
-        api_proxy = APIProxy()
-        api_proxy.coresys = self.coresys
-
-        self.webapp.add_routes(
-            [
-                web.get("/homeassistant/api/websocket", api_proxy.websocket),
-                web.get("/homeassistant/websocket", api_proxy.websocket),
-                web.get("/homeassistant/api/stream", api_proxy.stream),
-                web.post("/homeassistant/api/{path:.+}", api_proxy.api),
-                web.get("/homeassistant/api/{path:.+}", api_proxy.api),
-                web.get("/homeassistant/api/", api_proxy.api),
-            ]
-        )
-
-    def _register_addons(self) -> None:
-        """Register Add-on functions."""
-        api_addons = APIAddons()
-        api_addons.coresys = self.coresys
-
-        self.webapp.add_routes(
-            [
-                web.get("/addons", api_addons.list),
-                web.post("/addons/reload", api_addons.reload),
-                web.get("/addons/{addon}/info", api_addons.info),
-                web.post("/addons/{addon}/install", api_addons.install),
-                web.post("/addons/{addon}/uninstall", api_addons.uninstall),
-                web.post("/addons/{addon}/start", api_addons.start),
-                web.post("/addons/{addon}/stop", api_addons.stop),
-                web.post("/addons/{addon}/restart", api_addons.restart),
-                web.post("/addons/{addon}/update", api_addons.update),
-                web.post("/addons/{addon}/options", api_addons.options),
-                web.post("/addons/{addon}/rebuild", api_addons.rebuild),
-                web.get("/addons/{addon}/logs", api_addons.logs),
-                web.get("/addons/{addon}/icon", api_addons.icon),
-                web.get("/addons/{addon}/logo", api_addons.logo),
-                web.get("/addons/{addon}/changelog", api_addons.changelog),
-                web.post("/addons/{addon}/stdin", api_addons.stdin),
-                web.post("/addons/{addon}/security", api_addons.security),
-                web.get("/addons/{addon}/stats", api_addons.stats),
-            ]
-        )
-
-    def _register_ingress(self) -> None:
-        """Register Ingress functions."""
-        api_ingress = APIIngress()
-        api_ingress.coresys = self.coresys
-
-        self.webapp.add_routes(
-            [
-                web.post("/ingress/session", api_ingress.create_session),
-                web.get("/ingress/panels", api_ingress.panels),
-                web.view("/ingress/{token}/{path:.*}", api_ingress.handler),
-            ]
-        )
-
-    def _register_snapshots(self) -> None:
-        """Register snapshots functions."""
-        api_snapshots = APISnapshots()
-        api_snapshots.coresys = self.coresys
-
-        self.webapp.add_routes(
-            [
-                web.get("/snapshots", api_snapshots.list),
-                web.post("/snapshots/reload", api_snapshots.reload),
-                web.post("/snapshots/new/full", api_snapshots.snapshot_full),
-                web.post("/snapshots/new/partial", api_snapshots.snapshot_partial),
-                web.post("/snapshots/new/upload", api_snapshots.upload),
-                web.get("/snapshots/{snapshot}/info", api_snapshots.info),
-                web.post("/snapshots/{snapshot}/remove", api_snapshots.remove),
-                web.post(
-                    "/snapshots/{snapshot}/restore/full", api_snapshots.restore_full
-                ),
-                web.post(
-                    "/snapshots/{snapshot}/restore/partial",
-                    api_snapshots.restore_partial,
-                ),
-                web.get("/snapshots/{snapshot}/download", api_snapshots.download),
-            ]
-        )
-
-    def _register_services(self) -> None:
-        """Register services functions."""
-        api_services = APIServices()
-        api_services.coresys = self.coresys
-
-        self.webapp.add_routes(
-            [
-                web.get("/services", api_services.list),
-                web.get("/services/{service}", api_services.get_service),
-                web.post("/services/{service}", api_services.set_service),
-                web.delete("/services/{service}", api_services.del_service),
-            ]
-        )
-
-    def _register_discovery(self) -> None:
-        """Register discovery functions."""
-        api_discovery = APIDiscovery()
-        api_discovery.coresys = self.coresys
-
-        self.webapp.add_routes(
-            [
-                web.get("/discovery", api_discovery.list),
-                web.get("/discovery/{uuid}", api_discovery.get_discovery),
-                web.delete("/discovery/{uuid}", api_discovery.del_discovery),
-                web.post("/discovery", api_discovery.set_discovery),
-            ]
-        )
-
-    def _register_panel(self) -> None:
-        """Register panel for Home Assistant."""
-        panel_dir = Path(__file__).parent.joinpath("panel")
-        self.webapp.add_routes([web.static("/app", panel_dir)])
-
-    async def start(self) -> None:
-        """Run RESTful API webserver."""
-        await self._runner.setup()
-        self._site = web.TCPSite(
-            self._runner, host="0.0.0.0", port=80, shutdown_timeout=5
-        )
-
-        try:
-            await self._site.start()
-        except OSError as 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) -> 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,429 +0,0 @@
-"""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 ..addons import AnyAddon
-from ..addons.utils import rating_security
-from ..const import (
-    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 ..exceptions import APIError
-from ..validate import ALSA_DEVICE, DOCKER_PORTS
-from .utils import api_process, api_process_raw, api_validate
-
-_LOGGER = logging.getLogger(__name__)
-
-SCHEMA_VERSION = vol.Schema({vol.Optional(ATTR_VERSION): vol.Coerce(str)})
-
-# pylint: disable=no-value-for-parameter
-SCHEMA_OPTIONS = vol.Schema(
-    {
-        vol.Optional(ATTR_BOOT): vol.In([BOOT_AUTO, BOOT_MANUAL]),
-        vol.Optional(ATTR_NETWORK): vol.Any(None, DOCKER_PORTS),
-        vol.Optional(ATTR_AUTO_UPDATE): vol.Boolean(),
-        vol.Optional(ATTR_AUDIO_OUTPUT): ALSA_DEVICE,
-        vol.Optional(ATTR_AUDIO_INPUT): ALSA_DEVICE,
-        vol.Optional(ATTR_INGRESS_PANEL): vol.Boolean(),
-    }
-)
-
-# pylint: disable=no-value-for-parameter
-SCHEMA_SECURITY = vol.Schema({vol.Optional(ATTR_PROTECTED): vol.Boolean()})
-
-
-class APIAddons(CoreSysAttributes):
-    """Handle RESTful API for add-on functions."""
-
-    def _extract_addon(
-        self, request: web.Request, check_installed: bool = True
-    ) -> AnyAddon:
-        """Return addon, throw an exception it it doesn't exist."""
-        addon_slug = request.match_info.get("addon")
-
-        # Lookup itself
-        if addon_slug == "self":
-            return request.get(REQUEST_FROM)
-
-        addon = self.sys_addons.get(addon_slug)
-        if not addon:
-            raise APIError("Addon does not exist")
-
-        if check_installed and not addon.is_installed:
-            raise APIError("Addon is not installed")
-
-        return addon
-
-    @api_process
-    async def list(self, request: web.Request) -> Dict[str, Any]:
-        """Return all add-ons or repositories."""
-        data_addons = []
-        for addon in self.sys_addons.all:
-            data_addons.append(
-                {
-                    ATTR_NAME: addon.name,
-                    ATTR_SLUG: addon.slug,
-                    ATTR_DESCRIPTON: addon.description,
-                    ATTR_VERSION: addon.latest_version,
-                    ATTR_INSTALLED: addon.version if addon.is_installed else None,
-                    ATTR_AVAILABLE: addon.available,
-                    ATTR_DETACHED: addon.is_detached,
-                    ATTR_REPOSITORY: addon.repository,
-                    ATTR_BUILD: addon.need_build,
-                    ATTR_URL: addon.url,
-                    ATTR_ICON: addon.with_icon,
-                    ATTR_LOGO: addon.with_logo,
-                }
-            )
-
-        data_repositories = []
-        for repository in self.sys_store.all:
-            data_repositories.append(
-                {
-                    ATTR_SLUG: repository.slug,
-                    ATTR_NAME: repository.name,
-                    ATTR_SOURCE: repository.source,
-                    ATTR_URL: repository.url,
-                    ATTR_MAINTAINER: repository.maintainer,
-                }
-            )
-
-        return {ATTR_ADDONS: data_addons, ATTR_REPOSITORIES: data_repositories}
-
-    @api_process
-    async def reload(self, request: web.Request) -> None:
-        """Reload all add-on data from store."""
-        await asyncio.shield(self.sys_store.reload())
-
-    @api_process
-    async def info(self, request: web.Request) -> Dict[str, Any]:
-        """Return add-on information."""
-        addon = self._extract_addon(request, check_installed=False)
-
-        data = {
-            ATTR_NAME: addon.name,
-            ATTR_SLUG: addon.slug,
-            ATTR_DESCRIPTON: addon.description,
-            ATTR_LONG_DESCRIPTION: addon.long_description,
-            ATTR_AUTO_UPDATE: None,
-            ATTR_REPOSITORY: addon.repository,
-            ATTR_VERSION: None,
-            ATTR_LAST_VERSION: addon.latest_version,
-            ATTR_PROTECTED: addon.protected,
-            ATTR_RATING: rating_security(addon),
-            ATTR_BOOT: addon.boot,
-            ATTR_OPTIONS: addon.options,
-            ATTR_ARCH: addon.supported_arch,
-            ATTR_MACHINE: addon.supported_machine,
-            ATTR_HOMEASSISTANT: addon.homeassistant_version,
-            ATTR_URL: addon.url,
-            ATTR_STATE: STATE_NONE,
-            ATTR_DETACHED: addon.is_detached,
-            ATTR_AVAILABLE: addon.available,
-            ATTR_BUILD: addon.need_build,
-            ATTR_NETWORK: addon.ports,
-            ATTR_NETWORK_DESCRIPTION: addon.ports_description,
-            ATTR_HOST_NETWORK: addon.host_network,
-            ATTR_HOST_PID: addon.host_pid,
-            ATTR_HOST_IPC: addon.host_ipc,
-            ATTR_HOST_DBUS: addon.host_dbus,
-            ATTR_PRIVILEGED: addon.privileged,
-            ATTR_FULL_ACCESS: addon.with_full_access,
-            ATTR_APPARMOR: addon.apparmor,
-            ATTR_DEVICES: _pretty_devices(addon),
-            ATTR_ICON: addon.with_icon,
-            ATTR_LOGO: addon.with_logo,
-            ATTR_CHANGELOG: addon.with_changelog,
-            ATTR_STDIN: addon.with_stdin,
-            ATTR_WEBUI: None,
-            ATTR_HASSIO_API: addon.access_hassio_api,
-            ATTR_HASSIO_ROLE: addon.hassio_role,
-            ATTR_AUTH_API: addon.access_auth_api,
-            ATTR_HOMEASSISTANT_API: addon.access_homeassistant_api,
-            ATTR_GPIO: addon.with_gpio,
-            ATTR_KERNEL_MODULES: addon.with_kernel_modules,
-            ATTR_DEVICETREE: addon.with_devicetree,
-            ATTR_DOCKER_API: addon.access_docker_api,
-            ATTR_AUDIO: addon.with_audio,
-            ATTR_AUDIO_INPUT: None,
-            ATTR_AUDIO_OUTPUT: None,
-            ATTR_SERVICES: _pretty_services(addon),
-            ATTR_DISCOVERY: addon.discovery,
-            ATTR_IP_ADDRESS: None,
-            ATTR_INGRESS: addon.with_ingress,
-            ATTR_INGRESS_ENTRY: None,
-            ATTR_INGRESS_URL: None,
-            ATTR_INGRESS_PORT: None,
-            ATTR_INGRESS_PANEL: None,
-        }
-
-        if addon.is_installed:
-            data.update(
-                {
-                    ATTR_STATE: await addon.state(),
-                    ATTR_WEBUI: addon.webui,
-                    ATTR_INGRESS_ENTRY: addon.ingress_entry,
-                    ATTR_INGRESS_URL: addon.ingress_url,
-                    ATTR_INGRESS_PORT: addon.ingress_port,
-                    ATTR_INGRESS_PANEL: addon.ingress_panel,
-                    ATTR_AUDIO_INPUT: addon.audio_input,
-                    ATTR_AUDIO_OUTPUT: addon.audio_output,
-                    ATTR_AUTO_UPDATE: addon.auto_update,
-                    ATTR_IP_ADDRESS: str(addon.ip_address),
-                    ATTR_VERSION: addon.version,
-                }
-            )
-
-        return data
-
-    @api_process
-    async def options(self, request: web.Request) -> None:
-        """Store user options for add-on."""
-        addon = 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:
-            addon.options = body[ATTR_OPTIONS]
-        if ATTR_BOOT in body:
-            addon.boot = body[ATTR_BOOT]
-        if ATTR_AUTO_UPDATE in body:
-            addon.auto_update = body[ATTR_AUTO_UPDATE]
-        if ATTR_NETWORK in body:
-            addon.ports = body[ATTR_NETWORK]
-        if ATTR_AUDIO_INPUT in body:
-            addon.audio_input = body[ATTR_AUDIO_INPUT]
-        if ATTR_AUDIO_OUTPUT in body:
-            addon.audio_output = body[ATTR_AUDIO_OUTPUT]
-        if ATTR_INGRESS_PANEL in body:
-            addon.ingress_panel = body[ATTR_INGRESS_PANEL]
-            await self.sys_ingress.update_hass_panel(addon)
-
-        addon.save_persist()
-
-    @api_process
-    async def security(self, request: web.Request) -> None:
-        """Store security options for add-on."""
-        addon = 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_persist()
-
-    @api_process
-    async def stats(self, request: web.Request) -> Dict[str, Any]:
-        """Return resource information."""
-        addon = self._extract_addon(request)
-        stats = await addon.stats()
-
-        return {
-            ATTR_CPU_PERCENT: stats.cpu_percent,
-            ATTR_MEMORY_USAGE: stats.memory_usage,
-            ATTR_MEMORY_LIMIT: stats.memory_limit,
-            ATTR_NETWORK_RX: stats.network_rx,
-            ATTR_NETWORK_TX: stats.network_tx,
-            ATTR_BLK_READ: stats.blk_read,
-            ATTR_BLK_WRITE: stats.blk_write,
-        }
-
-    @api_process
-    def install(self, request: web.Request) -> Awaitable[None]:
-        """Install add-on."""
-        addon = self._extract_addon(request, check_installed=False)
-        return asyncio.shield(addon.install())
-
-    @api_process
-    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: web.Request) -> Awaitable[None]:
-        """Start add-on."""
-        addon = self._extract_addon(request)
-
-        # check options
-        options = addon.options
-        try:
-            addon.schema(options)
-        except vol.Invalid as ex:
-            raise APIError(humanize_error(options, ex)) from None
-
-        return asyncio.shield(addon.start())
-
-    @api_process
-    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: web.Request) -> Awaitable[None]:
-        """Update add-on."""
-        addon = self._extract_addon(request)
-
-        if addon.latest_version == addon.version:
-            raise APIError("No update available!")
-
-        return asyncio.shield(addon.update())
-
-    @api_process
-    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: web.Request) -> Awaitable[None]:
-        """Rebuild local build add-on."""
-        addon = self._extract_addon(request)
-        if not addon.need_build:
-            raise APIError("Only local build addons are supported")
-
-        return asyncio.shield(addon.rebuild())
-
-    @api_process_raw(CONTENT_TYPE_BINARY)
-    def logs(self, request: web.Request) -> Awaitable[bytes]:
-        """Return logs from add-on."""
-        addon = self._extract_addon(request)
-        return addon.logs()
-
-    @api_process_raw(CONTENT_TYPE_PNG)
-    async def icon(self, request: web.Request) -> bytes:
-        """Return icon from add-on."""
-        addon = self._extract_addon(request, check_installed=False)
-        if not addon.with_icon:
-            raise APIError("No icon found!")
-
-        with addon.path_icon.open("rb") as png:
-            return png.read()
-
-    @api_process_raw(CONTENT_TYPE_PNG)
-    async def logo(self, request: web.Request) -> bytes:
-        """Return logo from add-on."""
-        addon = self._extract_addon(request, check_installed=False)
-        if not addon.with_logo:
-            raise APIError("No logo found!")
-
-        with addon.path_logo.open("rb") as png:
-            return png.read()
-
-    @api_process_raw(CONTENT_TYPE_TEXT)
-    async def changelog(self, request: web.Request) -> str:
-        """Return changelog from add-on."""
-        addon = self._extract_addon(request, check_installed=False)
-        if not addon.with_changelog:
-            raise APIError("No changelog found!")
-
-        with addon.path_changelog.open("r") as changelog:
-            return changelog.read()
-
-    @api_process
-    async def stdin(self, request: web.Request) -> None:
-        """Write to stdin of add-on."""
-        addon = self._extract_addon(request)
-        if not addon.with_stdin:
-            raise APIError("STDIN not supported by add-on")
-
-        data = await request.read()
-        await asyncio.shield(addon.write_stdin(data))
-
-
-def _pretty_devices(addon: 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

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

hassio/api/hardware.py

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

hassio/api/hassos.py

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

hassio/api/host.py

@@ -1,109 +0,0 @@
-"""Init file for Hass.io host RESTful API."""
-import asyncio
-import logging
-
-import voluptuous as vol
-
-from .utils import api_process, api_validate
-from ..const import (
-    ATTR_HOSTNAME,
-    ATTR_FEATURES,
-    ATTR_KERNEL,
-    ATTR_OPERATING_SYSTEM,
-    ATTR_CHASSIS,
-    ATTR_DEPLOYMENT,
-    ATTR_STATE,
-    ATTR_NAME,
-    ATTR_DESCRIPTON,
-    ATTR_SERVICES,
-    ATTR_CPE,
-)
-from ..coresys import CoreSysAttributes
-
-_LOGGER = logging.getLogger(__name__)
-
-SERVICE = "service"
-
-SCHEMA_OPTIONS = vol.Schema({vol.Optional(ATTR_HOSTNAME): vol.Coerce(str)})
-
-
-class APIHost(CoreSysAttributes):
-    """Handle RESTful API for host functions."""
-
-    @api_process
-    async def info(self, request):
-        """Return host information."""
-        return {
-            ATTR_CHASSIS: self.sys_host.info.chassis,
-            ATTR_CPE: self.sys_host.info.cpe,
-            ATTR_FEATURES: self.sys_host.supperted_features,
-            ATTR_HOSTNAME: self.sys_host.info.hostname,
-            ATTR_OPERATING_SYSTEM: self.sys_host.info.operating_system,
-            ATTR_DEPLOYMENT: self.sys_host.info.deployment,
-            ATTR_KERNEL: self.sys_host.info.kernel,
-        }
-
-    @api_process
-    async def options(self, request):
-        """Edit host settings."""
-        body = await api_validate(SCHEMA_OPTIONS, request)
-
-        # hostname
-        if ATTR_HOSTNAME in body:
-            await asyncio.shield(
-                self.sys_host.control.set_hostname(body[ATTR_HOSTNAME])
-            )
-
-    @api_process
-    def reboot(self, request):
-        """Reboot host."""
-        return asyncio.shield(self.sys_host.control.reboot())
-
-    @api_process
-    def shutdown(self, request):
-        """Poweroff host."""
-        return asyncio.shield(self.sys_host.control.shutdown())
-
-    @api_process
-    def reload(self, request):
-        """Reload host data."""
-        return asyncio.shield(self.sys_host.reload())
-
-    @api_process
-    async def services(self, request):
-        """Return list of available services."""
-        services = []
-        for unit in self.sys_host.services:
-            services.append(
-                {
-                    ATTR_NAME: unit.name,
-                    ATTR_DESCRIPTON: unit.description,
-                    ATTR_STATE: unit.state,
-                }
-            )
-
-        return {ATTR_SERVICES: services}
-
-    @api_process
-    def service_start(self, request):
-        """Start a service."""
-        unit = request.match_info.get(SERVICE)
-        return asyncio.shield(self.sys_host.services.start(unit))
-
-    @api_process
-    def service_stop(self, request):
-        """Stop a service."""
-        unit = request.match_info.get(SERVICE)
-        return asyncio.shield(self.sys_host.services.stop(unit))
-
-    @api_process
-    def service_reload(self, request):
-        """Reload a service."""
-        unit = request.match_info.get(SERVICE)
-        return asyncio.shield(self.sys_host.services.reload(unit))
-
-    @api_process
-    def service_restart(self, request):
-        """Restart a service."""
-        unit = request.match_info.get(SERVICE)
-        return asyncio.shield(self.sys_host.services.restart(unit))

hassio/api/info.py

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

hassio/api/ingress.py

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

hassio/api/panel/chunk.5dd33a3a20657ed46a19.js.map

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

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

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

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

@@ -1,2 +0,0 @@
-(window.webpackJsonp=window.webpackJsonp||[]).push([[9],{101:function(n,r,t){"use strict";t.r(r),t.d(r,"marked",function(){return a}),t.d(r,"filterXSS",function(){return c});var e=t(124),i=t.n(e),o=t(126),u=t.n(o),a=i.a,c=u.a}}]);
-//# sourceMappingURL=chunk.7f8cce5798f837214ef8.js.map

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

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

hassio/api/panel/chunk.9d7374dae6137783dda4.js.LICENSE

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

@@ -1,2 +0,0 @@
-!function(e){function n(n){for(var t,o,a=n[0],i=n[1],f=0,c=[];f<a.length;f++)o=a[f],r[o]&&c.push(r[o][0]),r[o]=0;for(t in i)Object.prototype.hasOwnProperty.call(i,t)&&(e[t]=i[t]);for(u&&u(n);c.length;)c.shift()()}var t={},r={4:0};function o(n){if(t[n])return t[n].exports;var r=t[n]={i:n,l:!1,exports:{}};return e[n].call(r.exports,r,r.exports,o),r.l=!0,r.exports}o.e=function(e){var n=[],t=r[e];if(0!==t)if(t)n.push(t[2]);else{var a=new Promise(function(n,o){t=r[e]=[n,o]});n.push(t[2]=a);var i,f=document.createElement("script");f.charset="utf-8",f.timeout=120,o.nc&&f.setAttribute("nonce",o.nc),f.src=function(e){return o.p+"chunk."+{0:"7f411ffa9df152cb8f05",1:"598ae99dfd641ab3a30c",2:"af7784dbf07df8e24819",3:"b15efbd4fb2c8cac0ad4",5:"87d3a6d0178fb26762cf",6:"6f4702eafe52425373ed",7:"5dd33a3a20657ed46a19",8:"7c785f796f428abae18d",9:"7f8cce5798f837214ef8",10:"04bcaa18b59728e10be9",11:"9d7374dae6137783dda4",12:"6685a7f98b13655ab808",13:"f1156b978f6f3143a651"}[e]+".js"}(e),i=function(n){f.onerror=f.onload=null,clearTimeout(u);var t=r[e];if(0!==t){if(t){var o=n&&("load"===n.type?"missing":n.type),a=n&&n.target&&n.target.src,i=new Error("Loading chunk "+e+" failed.\n("+o+": "+a+")");i.type=o,i.request=a,t[1](i)}r[e]=void 0}};var u=setTimeout(function(){i({type:"timeout",target:f})},12e4);f.onerror=f.onload=i,document.head.appendChild(f)}return Promise.all(n)},o.m=e,o.c=t,o.d=function(e,n,t){o.o(e,n)||Object.defineProperty(e,n,{enumerable:!0,get:t})},o.r=function(e){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},o.t=function(e,n){if(1&n&&(e=o(e)),8&n)return e;if(4&n&&"object"==typeof e&&e&&e.__esModule)return e;var t=Object.create(null);if(o.r(t),Object.defineProperty(t,"default",{enumerable:!0,value:e}),2&n&&"string"!=typeof e)for(var r in e)o.d(t,r,function(n){return e[n]}.bind(null,r));return t},o.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return o.d(n,"a",n),n},o.o=function(e,n){return Object.prototype.hasOwnProperty.call(e,n)},o.p="/api/hassio/app/",o.oe=function(e){throw console.error(e),e};var a=window.webpackJsonp=window.webpackJsonp||[],i=a.push.bind(a);a.push=n,a=a.slice();for(var f=0;f<a.length;f++)n(a[f]);var u=i;o(o.s=0)}([function(e,n,t){window.loadES5Adapter().then(function(){Promise.all([t.e(1),t.e(6)]).then(t.bind(null,2)),Promise.all([t.e(1),t.e(12),t.e(8)]).then(t.bind(null,1))});var r=document.createElement("style");r.innerHTML="\nbody {\n  font-family: Roboto, sans-serif;\n  -moz-osx-font-smoothing: grayscale;\n  -webkit-font-smoothing: antialiased;\n  font-weight: 400;\n  margin: 0;\n  padding: 0;\n  height: 100vh;\n}\n",document.head.appendChild(r)}]);
-//# sourceMappingURL=entrypoint.js.map

hassio/api/panel/index.html

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

hassio/api/security.py

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