diff options
Diffstat (limited to 'test')
| -rw-r--r-- | test/Makefile | 1 | ||||
| -rwxr-xr-x | test/run.py | 370 | ||||
| -rwxr-xr-x | test/scripts/run_vpp_in_vm.sh | 198 | ||||
| -rw-r--r-- | test/test_vm_tap.py | 102 | ||||
| -rw-r--r-- | test/vpp_iperf.py | 118 | ||||
| -rw-r--r-- | test/vpp_qemu_utils.py | 20 |
6 files changed, 809 insertions, 0 deletions
diff --git a/test/Makefile b/test/Makefile index 08c6eabe100..e5c2b2d21d5 100644 --- a/test/Makefile +++ b/test/Makefile @@ -310,6 +310,7 @@ reset: @if [ $(FORCE_NO_WIPE) -eq "0" ] ; then rm -rf /tmp/vpp-unittest-*; fi @rm -f /tmp/api_post_mortem.* @rm -rf $(FAILED_DIR) + @rm -rf /tmp/vpp-vm-tests .PHONY: wipe wipe: reset diff --git a/test/run.py b/test/run.py new file mode 100755 index 00000000000..07b24d55b82 --- /dev/null +++ b/test/run.py @@ -0,0 +1,370 @@ +#!/usr/bin/env python3 +# +# Copyright (c) 2022 Cisco and/or its affiliates. +# 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. +# +# Build the Virtual Environment & run VPP unit tests + +import argparse +import glob +import logging +import os +from pathlib import Path +import signal +from subprocess import Popen, PIPE, STDOUT +import sys +import time +import venv + + +# Required Std. Path Variables +test_dir = os.path.dirname(os.path.realpath(__file__)) +ws_root = os.path.dirname(test_dir) +build_root = os.path.join(ws_root, "build-root") +venv_dir = os.path.join(test_dir, "venv") +venv_bin_dir = os.path.join(venv_dir, "bin") +venv_lib_dir = os.path.join(venv_dir, "lib") +venv_run_dir = os.path.join(venv_dir, "run") +venv_install_done = os.path.join(venv_run_dir, "venv_install.done") +papi_python_src_dir = os.path.join(ws_root, "src", "vpp-api", "python") + +# Path Variables Set after VPP Build/Install +vpp_build_dir = vpp_install_path = vpp_bin = vpp_lib = vpp_lib64 = None +vpp_plugin_path = vpp_test_plugin_path = ld_library_path = None + +# Pip version pinning +pip_version = "22.0.4" +pip_tools_version = "6.6.0" + +# Test requirement files +test_requirements_file = os.path.join(test_dir, "requirements.txt") +# Auto-generated requirement file +pip_compiled_requirements_file = os.path.join(test_dir, "requirements-3.txt") + + +# Gracefully exit after executing cleanup scripts +# upon receiving a SIGINT or SIGTERM +def handler(signum, frame): + print("Received Signal {0}".format(signum)) + post_vm_test_run() + + +signal.signal(signal.SIGINT, handler) +signal.signal(signal.SIGTERM, handler) + + +def show_progress(stream): + """ + Read lines from a subprocess stdout/stderr streams and write + to sys.stdout & the logfile + """ + while True: + s = stream.readline() + if not s: + break + data = s.decode("utf-8") + # Filter the annoying SIGTERM signal from the output when VPP is + # terminated after a test run + if "SIGTERM" not in data: + sys.stdout.write(data) + logging.debug(data) + sys.stdout.flush() + stream.close() + + +class ExtendedEnvBuilder(venv.EnvBuilder): + """ + 1. Builds a Virtual Environment for running VPP unit tests + 2. Installs all necessary scripts, pkgs & patches into the vEnv + - python3, pip, pip-tools, papi, scapy patches & + test-requirement pkgs + """ + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + + def post_setup(self, context): + """ + Setup all packages that need to be pre-installed into the venv + prior to running VPP unit tests. + + :param context: The context of the virtual environment creation + request being processed. + """ + os.environ["VIRTUAL_ENV"] = context.env_dir + os.environ[ + "CUSTOM_COMPILE_COMMAND" + ] = "make test-refresh-deps (or update requirements.txt)" + # Cleanup previously auto-generated pip req. file + try: + os.unlink(pip_compiled_requirements_file) + except OSError: + pass + # Set the venv python executable & binary install path + env_exe = context.env_exe + bin_path = context.bin_path + # Packages/requirements to be installed in the venv + # [python-module, cmdline-args, package-name_or_requirements-file-name] + test_req = [ + ["pip", "install", "pip===%s" % pip_version], + ["pip", "install", "pip-tools===%s" % pip_tools_version], + [ + "piptools", + "compile", + "-q", + "--generate-hashes", + test_requirements_file, + "--output-file", + pip_compiled_requirements_file, + ], + ["piptools", "sync", pip_compiled_requirements_file], + ["pip", "install", "-e", papi_python_src_dir], + ] + for req in test_req: + args = [env_exe, "-m"] + args.extend(req) + print(args) + p = Popen(args, stdout=PIPE, stderr=STDOUT, cwd=bin_path) + show_progress(p.stdout) + self.pip_patch() + + def pip_patch(self): + """ + Apply scapy patch files + """ + scapy_patch_dir = Path(os.path.join(test_dir, "patches", "scapy-2.4.3")) + scapy_source_dir = glob.glob( + os.path.join(venv_lib_dir, "python3.*", "site-packages") + )[0] + for f in scapy_patch_dir.iterdir(): + print("Applying patch: {}".format(os.path.basename(str(f)))) + args = ["patch", "--forward", "-p1", "-d", scapy_source_dir, "-i", str(f)] + print(args) + p = Popen(args, stdout=PIPE, stderr=STDOUT) + show_progress(p.stdout) + + +# Build VPP Release/Debug binaries +def build_vpp(debug=True, release=False): + """ + Install VPP Release(if release=True) or Debug(if debug=True) Binaries. + + Default is to build the debug binaries. + """ + global vpp_build_dir, vpp_install_path, vpp_bin, vpp_lib, vpp_lib64 + global vpp_plugin_path, vpp_test_plugin_path, ld_library_path + if debug: + print("Building VPP debug binaries") + args = ["make", "build"] + build = "build-vpp_debug-native" + install = "install-vpp_debug-native" + elif release: + print("Building VPP release binaries") + args = ["make", "build-release"] + build = "build-vpp-native" + install = "install-vpp-native" + p = Popen(args, stdout=PIPE, stderr=STDOUT, cwd=ws_root) + show_progress(p.stdout) + vpp_build_dir = os.path.join(build_root, build) + vpp_install_path = os.path.join(build_root, install) + vpp_bin = os.path.join(vpp_install_path, "vpp", "bin", "vpp") + vpp_lib = os.path.join(vpp_install_path, "vpp", "lib") + vpp_lib64 = os.path.join(vpp_install_path, "vpp", "lib64") + vpp_plugin_path = ( + os.path.join(vpp_lib, "vpp_plugins") + + ":" + + os.path.join(vpp_lib64, "vpp_plugins") + ) + vpp_test_plugin_path = ( + os.path.join(vpp_lib, "vpp_api_test_plugins") + + ":" + + os.path.join(vpp_lib64, "vpp_api_test_plugins") + ) + ld_library_path = os.path.join(vpp_lib) + ":" + os.path.join(vpp_lib64) + + +# Environment Vars required by the test framework, +# papi_provider & unittests +def set_environ(): + os.environ["WS_ROOT"] = ws_root + os.environ["BR"] = build_root + os.environ["VENV_PATH"] = venv_dir + os.environ["VENV_BIN"] = venv_bin_dir + os.environ["RND_SEED"] = str(time.time()) + os.environ["VPP_BUILD_DIR"] = vpp_build_dir + os.environ["VPP_BIN"] = vpp_bin + os.environ["VPP_PLUGIN_PATH"] = vpp_plugin_path + os.environ["VPP_TEST_PLUGIN_PATH"] = vpp_test_plugin_path + os.environ["VPP_INSTALL_PATH"] = vpp_install_path + os.environ["LD_LIBRARY_PATH"] = ld_library_path + os.environ["FAILED_DIR"] = "/tmp/vpp-failed-unittests/" + if not os.environ.get("TEST_JOBS"): + os.environ["TEST_JOBS"] = "1" + + +# Runs a test inside a spawned QEMU VM +# If a kernel image is not provided, a linux-image-kvm image is +# downloaded to the test_data_dir +def vm_test_runner(test_name, kernel_image, test_data_dir, cpu_mask, mem): + script = os.path.join(test_dir, "scripts", "run_vpp_in_vm.sh") + p = Popen( + [script, test_name, kernel_image, test_data_dir, cpu_mask, mem], + stdout=PIPE, + stderr=STDOUT, + cwd=ws_root, + ) + show_progress(p.stdout) + post_vm_test_run() + + +def post_vm_test_run(): + # Revert the ownership of certain directories from root to the + # original user after running in QEMU + print("Running post test cleanup tasks") + dirs = ["/tmp/vpp-failed-unittests", os.path.join(ws_root, "test", "__pycache__")] + dirs.extend(glob.glob("/tmp/vpp-unittest-*")) + dirs.extend(glob.glob("/tmp/api_post_mortem.*")) + user = os.getlogin() + for dir in dirs: + if os.path.exists(dir) and Path(dir).owner() != user: + cmd = ["sudo", "chown", "-R", "{0}:{0}".format(user), dir] + p = Popen(cmd, stdout=PIPE, stderr=STDOUT) + show_progress(p.stdout) + + +def build_venv(): + # Builds a virtual env containing all the required packages and patches + # for running VPP unit tests + if not os.path.exists(venv_install_done): + env_builder = ExtendedEnvBuilder(clear=True, with_pip=True) + print("Creating a vEnv for running VPP unit tests in {}".format(venv_dir)) + env_builder.create(venv_dir) + # Write state to the venv run dir + Path(venv_run_dir).mkdir(exist_ok=True) + Path(venv_install_done).touch() + + +def expand_mix_string(s): + # Returns an expanded string computed from a mixrange string (s) + # E.g: If param s = '5-8,10,11' returns '5,6,7,8,10,11' + result = [] + for val in s.split(","): + if "-" in val: + start, end = val.split("-") + result.extend(list(range(int(start), int(end) + 1))) + else: + result.append(int(val)) + return ",".join(str(i) for i in set(result)) + + +def set_logging(test_data_dir, test_name): + Path(test_data_dir).mkdir(exist_ok=True) + log_file = "vm_{0}_{1}.log".format(test_name, str(time.time())[-5:]) + filename = "{0}/{1}".format(test_data_dir, log_file) + Path(filename).touch() + logging.basicConfig(filename=filename, level=logging.DEBUG) + + +if __name__ == "__main__": + # Build a Virtual Environment for running tests on host & QEMU + parser = argparse.ArgumentParser( + description="Run VPP Unit Tests", formatter_class=argparse.RawTextHelpFormatter + ) + parser.add_argument( + "--vm", + dest="vm", + required=True, + action="store_true", + help="Run Test Inside a QEMU VM", + ) + parser.add_argument( + "-d", + "--debug", + dest="debug", + required=False, + default=True, + action="store_true", + help="Run Tests on Debug Build", + ) + parser.add_argument( + "-r", + "--release", + dest="release", + required=False, + default=False, + action="store_true", + help="Run Tests on release Build", + ) + parser.add_argument( + "--test", + dest="test_name", + required=False, + action="store", + default="", + help="Tests to Run", + ) + parser.add_argument( + "--vm-kernel-image", + dest="kernel_image", + required=False, + action="store", + default="", + help="Kernel Image Selection to Boot", + ) + parser.add_argument( + "--vm-cpu-list", + dest="vm_cpu_list", + required=False, + action="store", + default="5-8", + help="Set CPU Affinity\n" + "E.g. 5-7,10 will schedule on processors " + "#5, #6, #7 and #10. (Default: 5-8)", + ) + parser.add_argument( + "--vm-mem", + dest="vm_mem", + required=False, + action="store", + default="2", + help="Guest Memory in Gibibytes\n" "E.g. 4 (Default: 2)", + ) + args = parser.parse_args() + # Enable VM tests + if args.vm and args.test_name: + test_data_dir = "/tmp/vpp-vm-tests" + set_logging(test_data_dir, args.test_name) + vm_tests = True + elif args.vm and not args.test_name: + print("Error: The --test argument must be set for running VM tests") + sys.exit(1) + build_venv() + # Build VPP release or debug binaries + debug = False if args.release else True + build_vpp(debug, args.release) + set_environ() + if vm_tests: + print("Running VPP unit test(s):{0} inside a QEMU VM".format(args.test_name)) + # Check Available CPUs & Usable Memory + cpus = expand_mix_string(args.vm_cpu_list) + num_cpus, usable_cpus = (len(cpus.split(",")), len(os.sched_getaffinity(0))) + if num_cpus > usable_cpus: + print(f"Error:# of CPUs:{num_cpus} > Avail CPUs:{usable_cpus}") + sys.exit(1) + avail_mem = int(os.popen("free -t -g").readlines()[-1].split()[-1]) + if int(args.vm_mem) > avail_mem: + print(f"Error: Mem Size:{args.vm_mem}G > Avail Mem:{avail_mem}G") + sys.exit(1) + vm_test_runner( + args.test_name, args.kernel_image, test_data_dir, cpus, f"{args.vm_mem}G" + ) diff --git a/test/scripts/run_vpp_in_vm.sh b/test/scripts/run_vpp_in_vm.sh new file mode 100755 index 00000000000..8b8d14e9af3 --- /dev/null +++ b/test/scripts/run_vpp_in_vm.sh @@ -0,0 +1,198 @@ +#!/usr/bin/env bash +# Run VPP in a QEMU VM +# set -o xtrace +set -o nounset + +# Arguments: +# $1:- Test Filter +# $2:- Kernel Image +# $3:- Test Data Directory +# $4:- CPU Mask String (e.g. "5,6,7,8") +# $5:- Guest MEM in Gibibytes (e.g. 2G) + +if [[ -z "${1:-}" ]]; then + echo "ERROR: A non-empty test selection is required to run + tests in a QEMU VM" + exit 1 +fi +TEST=${1:-} +TEST_JOBS=${TEST_JOBS:-1} + +# Init RAM disk image to boot the QEMU VM +INITRD=${INITRD:-} + +# Ensure test dir +TEST_DATA_DIR=${3:-"/tmp/vpp-vm-tests"} +if [[ ! -d ${TEST_DATA_DIR} ]]; then + mkdir -p ${TEST_DATA_DIR} +fi + +# CPU Affinity for taskset +CPU_MASK=${4:-"5,6,7,8"} +IFS=',' read -r -a CPU_MASK_ARRAY <<< ${CPU_MASK} +CPUS=${#CPU_MASK_ARRAY[@]} + +# Guest MEM (Default 2G) +MEM=${5:-"2G"} + +# Set the QEMU executable for the OS pkg. +os_VENDOR=$(lsb_release -i -s) +if [[ $os_VENDOR =~ (Debian|Ubuntu) ]]; then + os_PACKAGE="deb" + QEMU=${QEMU:-"qemu-system-x86_64"} +else + os_PACKAGE="rpm" + QEMU=${QEMU:-"qemu-kvm"} +fi + +# Exit if the ${QEMU} executable is not available +if ! command -v ${QEMU} &> /dev/null; then + echo "Error: ${QEMU} is required, but could not be found." + exit 1 +fi + +# Download the Generic Linux Kernel, if needed +if [[ -z "${2:-}" ]] || [[ ! -f "${2:-}" ]]; then + if [[ $os_PACKAGE == "deb" ]]; then + PWD=$(pwd) + cd ${TEST_DATA_DIR} + PKG="linux-image-$(uname -r)" + echo "Getting the Linux Kernel image..${PKG}" + apt-get download ${PKG} + dpkg --fsys-tarfile ${PKG}_*.deb | tar xvf - ./boot + KERNEL_BIN=$(ls ${TEST_DATA_DIR}/boot/vmlinuz-*-generic) + cd ${PWD} + else + echo "ERROR: Kernel Image selection is required for RPM pkgs." + exit 1 + fi +else + KERNEL_BIN=${2:-} +fi + +## Create initrd with 9p drivers, if ${INITRD} is null +DRIVERS_9P="" +if [[ -z "${INITRD}" ]] && [[ ! -d "/etc/initramfs-tools" ]]; then + echo "To boot the QEMU VM, an initial RAM disk with 9p drivers is needed" + echo "Install the initramfs-tools package or set env var INITRD to the RAM disk path" + exit 1 +elif [[ -z "${INITRD}" ]]; then + if [[ -f "/etc/initramfs-tools/modules" ]]; then + DRIVERS_9P=$(grep 9p /etc/initramfs-tools/modules | awk '{print $1}' | cut -d$'\n' -f1) + fi + if [[ -z "${DRIVERS_9P}" ]]; then + echo "You'll need to update the file /etc/initramfs-tools/modules with the below 9p drivers" + echo "9p >> /etc/initramfs-tools/modules" + echo "9pnet >> /etc/initramfs-tools/modules" + echo "9pnet_virtio >> /etc/initramfs-tools/modules" + exit 1 + fi + # Generate the initramfs image, if the we haven't generated one yet + if ! ls ${TEST_DATA_DIR}/boot/initrd.img-*-generic &> /dev/null; then + echo "Generating a bootable initramfs image in ${TEST_DATA_DIR}/boot/" + update-initramfs -c -k $(uname -r) -b ${TEST_DATA_DIR}/boot >/dev/null 2>&1 + echo "Generated the INITRD image" + fi + INITRD=$(ls ${TEST_DATA_DIR}/boot/initrd.img-*-generic) +fi +echo "Using INITRD=${TEST_DATA_DIR}/boot/${INITRD} for booting the QEMU VM" + + +## Install iperf into ${TEST_DATA_DIR} +IPERF=${TEST_DATA_DIR}/usr/bin/iperf +if [[ ! -x ${IPERF} ]] && [[ $os_PACKAGE == "deb" ]]; then + echo "Installing iperf: ${IPERF}" + PWD=$(pwd) + cd ${TEST_DATA_DIR} + IPRF_PKG="iperf_2.0.5+dfsg1-2_amd64.deb" + wget https://iperf.fr/download/ubuntu/${IPRF_PKG} + dpkg --fsys-tarfile ${IPRF_PKG} | tar xvf - + if [[ -x ${IPERF} ]]; then + echo "${IPERF} installed successfully" + else + echo "ERROR: iperf executable ${IPERF} installation failed" + exit 1 + fi + cd ${PWD} +elif [[ ! -x ${IPERF} ]] && [[ $os_PACKAGE != "deb" ]]; then + echo "ERROR: install iperf: ${IPERF} before running QEMU tests" + exit 1 +fi + +FAILED_DIR=${FAILED_DIR:-"/tmp/vpp-failed-unittests/"} +if [[ ! -d ${FAILED_DIR} ]]; then + mkdir -p ${FAILED_DIR} +fi + +HUGEPAGES=${HUGEPAGES:-256} + +# Ensure all required Env vars are bound to non-zero values +EnvVarArray=("WS_ROOT=${WS_ROOT:-}" + "RND_SEED=${RND_SEED:-}" + "BR=${BR:-}" + "VENV_PATH=${VENV_PATH:-}" + "VPP_BUILD_DIR=${VPP_BUILD_DIR:-}" + "VPP_BIN=${VPP_BIN:-}" + "VPP_PLUGIN_PATH=${VPP_PLUGIN_PATH:-}" + "VPP_TEST_PLUGIN_PATH=${VPP_TEST_PLUGIN_PATH:-}" + "VPP_INSTALL_PATH=${VPP_INSTALL_PATH:-}" + "LD_LIBRARY_PATH=${LD_LIBRARY_PATH:-}") + +for envVar in ${EnvVarArray[*]}; do + var_name=$(echo $envVar | cut -d= -f1) + var_val=$(echo $envVar | cut -d= -f2) + if [[ -z "$var_val" ]]; then + echo "ERROR: Env var: $var_name is not set" + exit 1 + fi +done + +# Boot QEMU VM and run the test +function run_in_vm { + INIT=$(mktemp -p ${TEST_DATA_DIR}) + cat > ${INIT} << _EOF_ +#!/bin/bash +mkdir -p /dev/shm +mount -t tmpfs -o rw,nosuid,nodev tmpfs /dev/shm +mount -t devpts -o noexec,nosuid,gid=5,mode=0620 devpts /dev/pts || true +mount -t tmpfs -o "noexec,nosuid,size=10%,mode=0755" tmpfs /run +mount -t 9p /dev/vpp9p ${WS_ROOT} +mount -t 9p tmp9p /tmp +modprobe -a vhost_net +env SOCKET=1 SANITY=no \ +FAILED_DIR=${FAILED_DIR} RND_SEED=${RND_SEED} BR=${BR} \ +VENV_PATH=${VENV_PATH} TEST=${TEST} TEST_JOBS=${TEST_JOBS} \ +VPP_BUILD_DIR=${VPP_BUILD_DIR} VPP_BIN=${VPP_BIN} VPP_PLUGIN_PATH=${VPP_PLUGIN_PATH} \ +VPP_TEST_PLUGIN_PATH=${VPP_TEST_PLUGIN_PATH} VPP_INSTALL_PATH=${VPP_INSTALL_PATH} \ +LD_LIBRARY_PATH=${LD_LIBRARY_PATH} TEST_DATA_DIR=${TEST_DATA_DIR} INITRD=${INITRD} \ +bash -c "${WS_ROOT}/test/scripts/run.sh --filter=${TEST} --jobs=${TEST_JOBS} --failed-dir=${FAILED_DIR} \ +--venv-dir=${VENV_PATH} --vpp-ws-dir=${WS_ROOT} --extended" +poweroff -f +_EOF_ + + chmod +x ${INIT} + + sudo taskset -c ${CPU_MASK} ${QEMU} \ + -nodefaults \ + -name test_$(basename $INIT) \ + -chardev stdio,mux=on,id=char0 \ + -mon chardev=char0,mode=readline,pretty=on \ + -serial chardev:char0 \ + -machine pc,accel=kvm,usb=off,mem-merge=off \ + -cpu host \ + -smp ${CPUS},sockets=1,cores=${CPUS},threads=1 \ + -m ${MEM} \ + -no-user-config \ + -kernel ${KERNEL_BIN} \ + -initrd ${INITRD} \ + -fsdev local,id=root9p,path=/,security_model=none,multidevs=remap \ + -device virtio-9p-pci,fsdev=root9p,mount_tag=fsRoot \ + -virtfs local,path=${WS_ROOT},mount_tag=/dev/vpp9p,security_model=none,id=vpp9p,multidevs=remap \ + -virtfs local,path=/tmp,mount_tag=tmp9p,security_model=passthrough,id=tmp9p,multidevs=remap \ + -netdev tap,id=net0,vhost=on \ + -device virtio-net-pci,netdev=net0,mac=52:54:00:de:64:01 \ + -nographic \ + -append "ro root=fsRoot rootfstype=9p rootflags=trans=virtio,cache=mmap console=ttyS0 hugepages=${HUGEPAGES} init=${INIT}" + } + +run_in_vm diff --git a/test/test_vm_tap.py b/test/test_vm_tap.py new file mode 100644 index 00000000000..6787ca1e3d7 --- /dev/null +++ b/test/test_vm_tap.py @@ -0,0 +1,102 @@ +#!/usr/bin/env python3 +import unittest +from ipaddress import ip_interface +from vpp_qemu_utils import create_namespace +from vpp_iperf import VppIperf +from framework import VppTestCase, VppTestRunner +from config import config + + +class TestTapQemu(VppTestCase): + """Test Tap interfaces inside a QEMU VM. + + Start an iPerf connection stream between QEMU and VPP via + tap v2 interfaces. + + Linux_ns1 -- iperf_client -- tap1 -- VPP-BD -- tap2 -- + -- iperfServer -- Linux_ns2 + """ + + @classmethod + def setUpClass(cls): + super(TestTapQemu, cls).setUpClass() + + @classmethod + def tearDownClass(cls): + super(TestTapQemu, cls).tearDownClass() + + def setUp(self): + """Perform test setup before running QEMU tests. + + 1. Create a namespace for the iPerf Server & Client. + 2. Create 2 tap interfaces in VPP & add them to each namespace. + 3. Add the tap interfaces to a bridge-domain. + """ + super(TestTapQemu, self).setUp() + self.client_namespace = "iprf_client_ns" + self.server_namespace = "iprf_server_ns" + self.client_ip4_prefix = "10.0.0.101/24" + self.server_ip4_prefix = "10.0.0.102/24" + create_namespace(self.client_namespace) + create_namespace(self.server_namespace) + tap1_if_idx = self.create_tap( + 101, self.client_namespace, self.client_ip4_prefix + ) + tap2_if_idx = self.create_tap( + 102, self.server_namespace, self.server_ip4_prefix + ) + self.l2_connect_interfaces(tap1_if_idx, tap2_if_idx) + + def create_tap(self, id, host_namespace, host_ip4_prefix): + result = self.vapi.api( + self.vapi.papi.tap_create_v2, + { + "id": id, + "use_random_mac": True, + "host_namespace_set": True, + "host_namespace": host_namespace, + "host_if_name_set": False, + "host_bridge_set": False, + "host_mac_addr_set": False, + "host_ip4_prefix": ip_interface(host_ip4_prefix), + "host_ip4_prefix_set": True, + }, + ) + sw_if_index = result.sw_if_index + self.vapi.api( + self.vapi.papi.sw_interface_set_flags, + {"sw_if_index": sw_if_index, "flags": 1}, + ) + return sw_if_index + + def dump_vpp_tap_interfaces(self): + return self.vapi.api(self.vapi.papi.sw_interface_tap_v2_dump, {}) + + def dump_bridge_domain_details(self): + return self.vapi.api(self.vapi.papi.bridge_domain_dump, {"bd_id": 1}) + + def l2_connect_interfaces(self, *sw_if_idxs): + for if_idx in sw_if_idxs: + self.vapi.api( + self.vapi.papi.sw_interface_set_l2_bridge, + { + "rx_sw_if_index": if_idx, + "bd_id": 1, + "shg": 0, + "port_type": 0, + "enable": True, + }, + ) + + @unittest.skipUnless(config.extended, "part of extended tests") + def test_tap_iperf(self): + """Start an iperf connection stream between QEMU & VPP via tap.""" + iperf = VppIperf() + iperf.client_ns = self.client_namespace + iperf.server_ns = self.server_namespace + iperf.server_ip = str(ip_interface(self.server_ip4_prefix).ip) + iperf.start() + + +if __name__ == "__main__": + unittest.main(testRunner=VppTestRunner) diff --git a/test/vpp_iperf.py b/test/vpp_iperf.py new file mode 100644 index 00000000000..78ce9d08c90 --- /dev/null +++ b/test/vpp_iperf.py @@ -0,0 +1,118 @@ +#!/usr/bin/env python + +# Start an iPerf connection stream between two Linux namespaces ## + +import subprocess +import os + + +class VppIperf: + """ "Create an iPerf connection stream between two namespaces. + + Usage: + iperf = VppIperf() # Create the iPerf Object + iperf.client_ns = 'ns1' # Client Namespace + iperf.server_ns = 'ns2' # Server Namespace + iperf.server_ip = '10.0.0.102' # Server IP Address + iperf.start() # Start the connection stream + + Optional: + iperf.duration = 15 # Time to transmit for in seconds (Default=10) + + ## Optionally set any iperf client & server args + Example: + # Run 4 parallel streams, write to logfile & bind to port 5202 + iperf.client_args='-P 4 --logfile /tmp/vpp-vm-tests/vpp_iperf.log -p 5202' + iperf.server_args='-p 5202' + """ + + def __init__(self, server_ns=None, client_ns=None, server_ip=None): + self.server_ns = server_ns + self.client_ns = client_ns + self.server_ip = server_ip + self.duration = 10 + self.client_args = "" + self.server_args = "" + # Set the iperf executable + self.iperf = os.path.join(os.getenv("TEST_DATA_DIR") or "/", "usr/bin/iperf") + + def ensure_init(self): + if self.server_ns and self.client_ns and self.server_ip: + return True + else: + raise Exception( + "Error: Cannot Start." "iPerf object has not been initialized" + ) + + def start_iperf_server(self): + print("Starting iPerf Server Daemon in Namespace ", self.server_ns) + args = [ + "ip", + "netns", + "exec", + self.server_ns, + self.iperf, + "-s", + "-D", + "-B", + self.server_ip, + ] + args.extend(self.server_args.split()) + try: + subprocess.run( + args, + stderr=subprocess.STDOUT, + timeout=self.duration + 5, + encoding="utf-8", + ) + except subprocess.TimeoutExpired as e: + raise Exception("Error: Timeout expired for iPerf", e.output) + + def start_iperf_client(self): + print("Starting iPerf Client in Namespace ", self.client_ns) + args = [ + "ip", + "netns", + "exec", + self.client_ns, + self.iperf, + "-c", + self.server_ip, + "-t", + str(self.duration), + ] + args.extend(self.client_args.split()) + try: + subprocess.run( + args, + stderr=subprocess.STDOUT, + timeout=self.duration + 5, + encoding="utf-8", + ) + except subprocess.TimeoutExpired as e: + raise Exception("Error: Timeout expired for iPerf", e.output) + + def start(self): + """Run iPerf and return True if successful""" + self.ensure_init() + try: + self.start_iperf_server() + except Exception as e: + subprocess.run(["pkill", "iperf"]) + raise Exception("Error starting iPerf Server", e) + + try: + self.start_iperf_client() + except Exception as e: + raise Exception("Error starting iPerf Client", e) + subprocess.run(["pkill", "iperf"]) + + +if __name__ == "__main__": + # Run iPerf using default settings + iperf = VppIperf() + iperf.client_ns = "ns1" + iperf.server_ns = "ns2" + iperf.server_ip = "10.0.0.102" + iperf.duration = 20 + iperf.start() diff --git a/test/vpp_qemu_utils.py b/test/vpp_qemu_utils.py new file mode 100644 index 00000000000..50fc1c865a6 --- /dev/null +++ b/test/vpp_qemu_utils.py @@ -0,0 +1,20 @@ +#!/usr/bin/env python + +# Utility functions for QEMU tests ## + +import subprocess + + +def create_namespace(ns): + try: + subprocess.run(["ip", "netns", "add", ns]) + except subprocess.CalledProcessError as e: + raise Exception("Error creating namespace:", e.output) + + +def list_namespace(ns): + """List the IP address of a namespace""" + try: + subprocess.run(["ip", "netns", "exec", ns, "ip", "addr"]) + except subprocess.CalledProcessError as e: + raise Exception("Error listing namespace IP:", e.output) |