Add qemu testing to CI

jlatusek · jlatusek · commit 319502548a53 · 2024-04-08T11:24:44.000+02:00
diff --git a/.github/workflows/qemu.yaml b/.github/workflows/qemu.yaml
@@ -97,3 +97,66 @@ jobs:
                         --target tizen-arm-tests-no-ble-no-thread \
                         build
                     "
+
+    qemu-linux:
+        name: ubuntu
+
+        runs-on: ubuntu-latest
+        if: github.actor != 'restyled-io[bot]'
+
+        container:
+            image: ghcr.io/jlatusek/chip-build-linux-qemu:latest
+            volumes:
+                - "/tmp/log_output:/tmp/test_logs"
+            # Required for using KVM
+            options: --privileged
+
+        steps:
+            - name: Checkout
+              uses: actions/checkout@v4
+            - name: Checkout submodules & Bootstrap
+              uses: ./.github/actions/checkout-submodules-and-bootstrap
+              with:
+                platform: linux
+
+            - name: Build Apps
+              run: |
+                  scripts/run_in_build_env.sh './scripts/build_python.sh --install_virtual_env out/venv'
+                  ./scripts/run_in_build_env.sh \
+                     "./scripts/build/build_examples.py \
+                        --target linux-x64-chip-tool \
+                        --target linux-x64-all-clusters \
+                        build \
+                        --copy-artifacts-to objdir-clone \
+                     "
+            # There is no enough space for running the test withouth cleaning the environment
+            - name: Clean up
+              run: |
+                rm -rf out/*/obj
+                rm -rf out/*/lib
+                rm -rf $PW_ENVIRONMENT_ROOT
+                git clean -fdx --exclude out
+            # Without all required apps paths provided as argument, script starts to search for them in the current directory and it takes a lot of time.
+            - name: Run ble commission test using the python parser sending commands to chip-tool
+              run: |
+                ./scripts/run_in_vm.sh \
+                "./scripts/run_in_build_env.sh \
+                \"./scripts/tests/run_test_suite.py \
+                  --runner chip_tool_python \
+                  --target TestCommissionerNodeId \
+                  --chip-tool ./out/linux-x64-chip-tool/chip-tool \
+                  run \
+                    --iterations 1 \
+                    --test-timeout-seconds 120 \
+                    --all-clusters-app ./out/linux-x64-all-clusters/chip-all-clusters-app \
+                    --lock-app ./out/linux-x64-lock/chip-lock-app \
+                    --ota-provider-app ./out/linux-x64-ota-provider/chip-ota-provider-app \
+                    --ota-requestor-app ./out/linux-x64-ota-requestor/chip-ota-requestor-app \
+                    --tv-app ./out/linux-x64-tv-app/chip-tv-app \
+                    --bridge-app ./out/linux-x64-bridge/chip-bridge-app \
+                    --lit-icd-app ./out/linux-x64-lit-icd/lit-icd-app \
+                    --microwave-oven-app .out/linux-x64-microwave-oven/chip-microwave-oven-app  \
+                    --rvc-app .out/linux-x64-rvc/chip-rvc-app  \
+                    --ble-wifi \
+                \" \
+                "
diff --git a/.gitignore b/.gitignore
@@ -84,3 +84,5 @@ examples/*/esp32/dependencies.lock
 # jupyter temporary files
 .ipynb_checkpoints
 
+/runner.sh
+/runner_status
diff --git a/scripts/run_in_vm.sh b/scripts/run_in_vm.sh
@@ -0,0 +1,36 @@
+#!/usr/bin/env bash
+#
+# Copyright (c) 2024 Project CHIP Authors
+#
+# 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.
+#
+
+# This script executes the command given as an argument after
+# activating the given python virtual environment
+set -e
+
+PROJECT_PATH=$(dirname "$(dirname "$(realpath "$0")")")
+
+echo "$@" >"$PROJECT_PATH/runner.sh"
+chmod +x "$PROJECT_PATH/runner.sh"
+
+echo "CMD:"
+cat "$PROJECT_PATH/runner.sh"
+
+"$PROJECT_PATH/integrations/docker/images/stage-2/chip-build-linux-qemu/run-img.sh"
+
+if [ -f "$PROJECT_PATH/runner_status" ]; then
+    exit "$(cat "$PROJECT_PATH/runner_status")"
+else
+    exit 1
+fi
diff --git a/scripts/setup/requirements.all.txt b/scripts/setup/requirements.all.txt
@@ -42,6 +42,7 @@ mypy==0.971
 mypy-protobuf==3.5.0
 protobuf==4.24.4
 types-protobuf==4.24.0.2
+PyGObject
 
 cryptography
 
diff --git a/scripts/tests/chiptest/linux.py b/scripts/tests/chiptest/linux.py
@@ -18,15 +18,22 @@
 Handles linux-specific functionality for running test cases
 """
 
+import glob
 import logging
 import os
+import shutil
 import subprocess
 import sys
 import time
+from collections import namedtuple
+from time import sleep
+from typing import Optional
 
 from .test_definition import ApplicationPaths
 
 test_environ = os.environ.copy()
+PW_PROJECT_ROOT = os.environ.get("PW_PROJECT_ROOT")
+QEMU_CONFIG_FILES = "integrations/docker/images/stage-2/chip-build-linux-qemu/files"
 
 
 def EnsureNetworkNamespaceAvailability():
@@ -169,6 +176,174 @@ def ShutdownNamespaceForTestExecution():
     RemoveNamespaceForAppTest()
 
 
+class DbusTest:
+    DBUS_SYSTEM_BUS_ADDRESS = "unix:path=/tmp/chip-dbus-test"
+
+    def __init__(self):
+        self._dbus = None
+        self._dbus_proxy = None
+
+    def start(self):
+        original_env = os.environ.copy()
+        os.environ["DBUS_SYSTEM_BUS_ADDRESS"] = DbusTest.DBUS_SYSTEM_BUS_ADDRESS
+        dbus = shutil.which("dbus-daemon")
+        self._dbus = subprocess.Popen(
+            [dbus, "--session", "--address", self.DBUS_SYSTEM_BUS_ADDRESS])
+
+        self._dbus_proxy = subprocess.Popen(
+            ["python3", f"{PW_PROJECT_ROOT}/scripts/tools/dbus-proxy-bluez.py", "--bus-proxy", DbusTest.DBUS_SYSTEM_BUS_ADDRESS], env=original_env)
+
+    def stop(self):
+        if self._dbus:
+            self._dbus_proxy.terminate()
+            self._dbus.terminate()
+            self._dbus.wait()
+
+
+class VirtualWifi:
+    def __init__(self, hostapd_path: str, dnsmasq_path: str, wpa_supplicant_path: str, wlan_app: Optional[str] = None, wlan_tool: Optional[str] = None):
+        self._hostapd_path = hostapd_path
+        self._dnsmasq_path = dnsmasq_path
+        self._wpa_supplicant_path = wpa_supplicant_path
+        self._hostapd_conf = os.path.join(
+            PW_PROJECT_ROOT, QEMU_CONFIG_FILES, "wifi/hostapd.conf")
+        self._dnsmasq_conf = os.path.join(
+            PW_PROJECT_ROOT, QEMU_CONFIG_FILES, "wifi/dnsmasq.conf")
+        self._wpa_supplicant_conf = os.path.join(
+            PW_PROJECT_ROOT, QEMU_CONFIG_FILES, "wifi/wpa_supplicant.conf")
+
+        if wlan_app is None or wlan_tool is None:
+            wlans = glob.glob(
+                "/sys/devices/virtual/mac80211_hwsim/hwsim*/net/*")
+            if len(wlans) < 2:
+                raise RuntimeError("Not enough wlan devices found")
+
+            self._wlan_app = os.path.basename(wlans[0])
+            self._wlan_tool = os.path.basename(wlans[1])
+        else:
+            self._wlan_app = wlan_app
+            self._wlan_tool = wlan_tool
+        self._hostapd = None
+        self._dnsmasq = None
+        self._wpa_supplicant = None
+
+    @staticmethod
+    def _get_phy(dev: str) -> str:
+        output = subprocess.check_output(['iw', 'dev', dev, 'info'])
+        for line in output.split(b'\n'):
+            if b'wiphy' in line:
+                wiphy = int(line.split(b' ')[1])
+                return f"phy{wiphy}"
+        raise ValueError(f'No wiphy found for {dev}')
+
+    @staticmethod
+    def _move_phy_to_netns(phy: str, netns: str):
+        subprocess.check_call(
+            ["iw", "phy", phy, "set", "netns", "name", netns])
+
+    @staticmethod
+    def _set_interface_ip_in_netns(netns: str, dev: str, ip: str):
+        subprocess.check_call(
+            ["ip", "netns", "exec", netns, "ip", "link", "set", "dev", dev, "up"])
+        subprocess.check_call(
+            ["ip", "netns", "exec", netns, "ip", "addr", "add", ip, "dev", dev])
+
+    def start(self):
+        self._move_phy_to_netns(self._get_phy(self._wlan_app), 'app')
+        self._move_phy_to_netns(self._get_phy(self._wlan_tool), 'tool')
+        self._set_interface_ip_in_netns(
+            'tool', self._wlan_tool, '192.168.200.1/24')
+
+        self._hostapd = subprocess.Popen(["ip", "netns", "exec", "tool", self._hostapd_path,
+                                          self._hostapd_conf], stdout=subprocess.DEVNULL)
+        self._dnsmasq = subprocess.Popen(["ip", "netns", "exec", "tool", self._dnsmasq_path,
+                                          '-d', '-C', self._dnsmasq_conf], stdout=subprocess.DEVNULL)
+        self._wpa_supplicant = subprocess.Popen(
+            ["ip", "netns", "exec", "app", self._wpa_supplicant_path, "-u", '-s', '-c', self._wpa_supplicant_conf], stdout=subprocess.DEVNULL)
+
+    def stop(self):
+        if self._hostapd:
+            self._hostapd.terminate()
+            self._hostapd.wait()
+        if self._dnsmasq:
+            self._dnsmasq.terminate()
+            self._dnsmasq.wait()
+        if self._wpa_supplicant:
+            self._wpa_supplicant.terminate()
+            self._wpa_supplicant.wait()
+
+
+class VirtualBle:
+    BleDevice = namedtuple('BleDevice', ['hci', 'mac', 'index'])
+
+    def __init__(self, btvirt_path: str, bluetoothctl_path: str):
+        self._btvirt_path = btvirt_path
+        self._bluetoothctl_path = bluetoothctl_path
+        self._btvirt = None
+        self._bluetoothctl = None
+        self._ble_app = None
+        self._ble_tool = None
+
+    @property
+    def ble_app(self) -> Optional[BleDevice]:
+        if not self._ble_app:
+            raise RuntimeError("Bluetooth not started")
+        return self._ble_app
+
+    @property
+    def ble_tool(self) -> Optional[BleDevice]:
+        if not self._ble_tool:
+            raise RuntimeError("Bluetooth not started")
+        return self._ble_tool
+
+    def bletoothctl_cmd(self, cmd):
+        self._bluetoothctl.stdin.write(cmd)
+        self._bluetoothctl.stdin.flush()
+
+    def _get_mac_address(self, hci_name):
+        result = subprocess.run(
+            ['hcitool', 'dev'], capture_output=True, text=True)
+        lines = result.stdout.splitlines()
+
+        for line in lines:
+            if hci_name in line:
+                mac_address = line.split()[1]
+                return mac_address
+
+        raise RuntimeError(f"No MAC address found for device {hci_name}")
+
+    def _get_ble_info(self):
+        ble_dev_paths = glob.glob("/sys/devices/virtual/bluetooth/hci*")
+        hci = [os.path.basename(path) for path in ble_dev_paths]
+        if len(hci) < 2:
+            raise RuntimeError("Not enough BLE devices found")
+        self._ble_app = self.BleDevice(
+            hci=hci[0], mac=self._get_mac_address(hci[0]), index=int(hci[0].replace('hci', '')))
+        self._ble_tool = self.BleDevice(
+            hci=hci[1], mac=self._get_mac_address(hci[1]), index=int(hci[1].replace('hci', '')))
+
+    def _run_bluetoothctl(self):
+        self._bluetoothctl = subprocess.Popen([self._bluetoothctl_path], text=True,
+                                              stdin=subprocess.PIPE, stdout=subprocess.DEVNULL)
+        self.bletoothctl_cmd(f"select {self.ble_app.mac}\n")
+        self.bletoothctl_cmd("power on\n")
+        self.bletoothctl_cmd(f"select {self.ble_tool.mac}\n")
+        self.bletoothctl_cmd("power on\n")
+        self.bletoothctl_cmd("quit\n")
+        self._bluetoothctl.wait()
+
+    def start(self):
+        self._btvirt = subprocess.Popen([self._btvirt_path, '-l2'])
+        sleep(1)
+        self._get_ble_info()
+        self._run_bluetoothctl()
+
+    def stop(self):
+        if self._btvirt:
+            self._btvirt.terminate()
+            self._btvirt.wait()
+
+
 def PathsWithNetworkNamespaces(paths: ApplicationPaths) -> ApplicationPaths:
     """
     Returns a copy of paths with updated command arrays to invoke the
diff --git a/scripts/tests/chiptest/test_definition.py b/scripts/tests/chiptest/test_definition.py
@@ -284,7 +284,7 @@ def tags_str(self) -> str:
         return ", ".join([t.to_s() for t in self.tags])
 
     def Run(self, runner, apps_register, paths: ApplicationPaths, pics_file: str,
-            timeout_seconds: typing.Optional[int], dry_run=False, test_runtime: TestRunTime = TestRunTime.CHIP_TOOL_PYTHON):
+            timeout_seconds: typing.Optional[int], dry_run=False, test_runtime: TestRunTime = TestRunTime.CHIP_TOOL_PYTHON, app_hci_number: typing.Optional[int] = None, tool_hci_number: typing.Optional[int] = None):
         """
         Executes the given test case using the provided runner for execution.
         """
@@ -331,8 +331,11 @@ def Run(self, runner, apps_register, paths: ApplicationPaths, pics_file: str,
                         key = 'default'
                     else:
                         key = os.path.basename(path[-1])
-
-                    app = App(runner, path)
+                    ble_wifi_cmd = []
+                    if app_hci_number is not None:
+                        ble_wifi_cmd = ["--ble-device",
+                                        str(app_hci_number), "--wifi"]
+                    app = App(runner, path + ble_wifi_cmd)
                     # Add the App to the register immediately, so if it fails during
                     # start() we will be able to clean things up properly.
                     apps_register.add(key, app)
@@ -372,11 +375,19 @@ def Run(self, runner, apps_register, paths: ApplicationPaths, pics_file: str,
                     runner.RunSubprocess(python_cmd, name='CHIP_REPL_YAML_TESTER',
                                          dependencies=[apps_register], timeout_seconds=timeout_seconds)
             else:
-                pairing_cmd = paths.chip_tool_with_python_cmd + ['pairing', 'code', TEST_NODE_ID, setupCode]
+                pairing_server_args = []
+                if tool_hci_number is not None:
+                    pairing_cmd = paths.chip_tool_with_python_cmd + [
+                        "pairing", "ble-wifi",  TEST_NODE_ID, "Virtual_Wifi", "ExamplePassword", "20202021",  "3840", ]
+                    pairing_server_args = [
+                        "--ble-adapter", str(tool_hci_number)]
+                else:
+                    pairing_cmd = paths.chip_tool_with_python_cmd + ['pairing', 'code', TEST_NODE_ID, setupCode]
                 test_cmd = paths.chip_tool_with_python_cmd + ['tests', self.run_name] + ['--PICS', pics_file]
                 server_args = ['--server_path', paths.chip_tool[-1]] + \
                     ['--server_arguments', 'interactive server' +
-                        (' ' if len(tool_storage_args) else '') + ' '.join(tool_storage_args)]
+                        (' ' if len(tool_storage_args) else '') + ' '.join(tool_storage_args) +
+                        (' ' if len(pairing_server_args) else '') + ' '.join(pairing_server_args)]
                 pairing_cmd += server_args
                 test_cmd += server_args
 
diff --git a/scripts/tests/run_test_suite.py b/scripts/tests/run_test_suite.py
