Signed-off-by: David Gibson --- test/nstool.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/test/nstool.c b/test/nstool.c index 1bdf44e8..a6aca981 100644 --- a/test/nstool.c +++ b/test/nstool.c @@ -359,7 +359,7 @@ static void wait_for_child(pid_t pid) if (rc != pid) die("waitpid() on %d returned %d", pid, rc); if (WIFSTOPPED(status)) { - /* Stop the parent to patch */ + /* Stop the parent to match */ kill(getpid(), SIGSTOP); /* We must have resumed, resume the child */ kill(pid, SIGCONT); @@ -508,7 +508,7 @@ static void cmd_exec(int argc, char *argv[]) /* CHILD */ if (argc > optind + 1) { exe = argv[optind + 1]; - xargs = (const char * const*)(argv + optind + 1); + xargs = (const char *const *)(argv + optind + 1); } else { exe = getenv("SHELL"); if (!exe) -- 2.45.2

Add a new 'avocado' target to the test/ Makefile, which will install avocado into a Python venv, and run the Avocado based tests with it. Signed-off-by: David Gibson --- test/.gitignore | 1 + test/Makefile | 16 ++++++++++++++++ test/run_avocado | 9 +++++---- 3 files changed, 22 insertions(+), 4 deletions(-) diff --git a/test/.gitignore b/test/.gitignore index 6dd4790b..a79d5b6f 100644 --- a/test/.gitignore +++ b/test/.gitignore @@ -10,3 +10,4 @@ QEMU_EFI.fd nstool guest-key guest-key.pub +/venv/ diff --git a/test/Makefile b/test/Makefile index 35a3b559..fda62984 100644 --- a/test/Makefile +++ b/test/Makefile @@ -63,6 +63,12 @@ LOCAL_ASSETS = mbuto.img mbuto.mem.img podman/bin/podman QEMU_EFI.fd \ ASSETS = $(DOWNLOAD_ASSETS) $(LOCAL_ASSETS) +SYSTEM_PYTHON = python3 +VENV = venv +PYTHON = $(VENV)/bin/python3 +PIP = $(VENV)/bin/pip3 +RUN_AVOCADO = cd .. && test/$(PYTHON) test/run_avocado + CFLAGS = -Wall -Werror -Wextra -pedantic -std=c99 assets: $(ASSETS) @@ -116,6 +122,15 @@ medium.bin: big.bin: dd if=/dev/urandom bs=1M count=10 of=$@ +.PHONY: venv +venv: + $(SYSTEM_PYTHON) -m venv $(VENV) + $(PIP) install avocado-framework + +.PHONY: avocado +avocado: venv + $(RUN_AVOCADO) avocado + check: assets ./run @@ -127,6 +142,7 @@ clean: rm -f $(LOCAL_ASSETS) rm -rf test_logs rm -f prepared-*.qcow2 prepared-*.img + rm -rf $(VENV) realclean: clean rm -rf $(DOWNLOAD_ASSETS) diff --git a/test/run_avocado b/test/run_avocado index 37db17c3..19a94a8f 100755 --- a/test/run_avocado +++ b/test/run_avocado @@ -32,12 +32,13 @@ from avocado.core.suite import TestSuite def main(): repo_root_path = os.path.abspath( - os.path.dirname(os.path.dirname(os.path.dirname(__file__))) + os.path.dirname(os.path.dirname(__file__)) ) + + references = [os.path.join(repo_root_path, 'test', x) for x in sys.argv[1:]] + config = { - "resolver.references": [ - os.path.join(repo_root_path, "test", "avocado", "static_checkers.json") - ], + "resolver.references": references, "runner.identifier_format": "{args[0]}", } suite = TestSuite.from_config(config, name="static_checkers") -- 2.45.2

Add a new test script to run the equivalent of the tests in build/all using exeter and Avocado. This new version of the tests is more robust than the original, since it makes a temporary copy of the source tree so will not be affected by concurrent manual builds. Signed-off-by: David Gibson --- test/Makefile | 19 +++++--- test/build/.gitignore | 1 + test/build/build.py | 105 ++++++++++++++++++++++++++++++++++++++++++ test/run_avocado | 2 +- 4 files changed, 120 insertions(+), 7 deletions(-) create mode 100644 test/build/build.py diff --git a/test/Makefile b/test/Makefile index dae25312..d24fce14 100644 --- a/test/Makefile +++ b/test/Makefile @@ -64,15 +64,19 @@ LOCAL_ASSETS = mbuto.img mbuto.mem.img podman/bin/podman QEMU_EFI.fd \ ASSETS = $(DOWNLOAD_ASSETS) $(LOCAL_ASSETS) EXETER_SH = build/static_checkers.sh -EXETER_JOBS = $(EXETER_SH:%.sh=%.json) +EXETER_PY = build/build.py +EXETER_JOBS = $(EXETER_SH:%.sh=%.json) $(EXETER_PY:%.py=%.json) AVOCADO_JOBS = $(EXETER_JOBS) avocado/static_checkers.json -SYSTEM_PYTHON = python3 +PYTHON = python3 VENV = venv -PYTHON = $(VENV)/bin/python3 PIP = $(VENV)/bin/pip3 -RUN_AVOCADO = cd .. && test/$(PYTHON) test/run_avocado +PYPATH = exeter/py3 +SPACE = $(subst ,, ) +PYPATH_TEST = $(subst $(SPACE),:,$(PYPATH)) +PYPATH_BASE = $(subst $(SPACE),:,$(PYPATH:%=test/%)) +RUN_AVOCADO = cd .. && PYTHONPATH=$(PYPATH_BASE) test/$(VENV)/bin/python3 test/run_avocado CFLAGS = -Wall -Werror -Wextra -pedantic -std=c99 @@ -131,13 +135,16 @@ big.bin: dd if=/dev/urandom bs=1M count=10 of=$@ .PHONY: venv -venv: - $(SYSTEM_PYTHON) -m venv $(VENV) +venv: pull-exeter + $(PYTHON) -m venv $(VENV) $(PIP) install avocado-framework %.json: %.sh pull-exeter cd ..; sh test/$< --avocado > test/$@ +%.json: %.py pull-exeter + cd ..; PYTHONPATH=$(PYPATH_BASE) $(PYTHON) test/$< --avocado > test/$@ + .PHONY: avocado avocado: venv $(AVOCADO_JOBS) $(RUN_AVOCADO) $(AVOCADO_JOBS) diff --git a/test/build/.gitignore b/test/build/.gitignore index a6c57f5f..4ef40dd0 100644 --- a/test/build/.gitignore +++ b/test/build/.gitignore @@ -1 +1,2 @@ *.json +build.exeter diff --git a/test/build/build.py b/test/build/build.py new file mode 100644 index 00000000..79668672 --- /dev/null +++ b/test/build/build.py @@ -0,0 +1,105 @@ +#! /usr/bin/env python3 +# +# SPDX-License-Identifier: GPL-2.0-or-later +# +# PASST - Plug A Simple Socket Transport +# for qemu/UNIX domain socket mode +# +# PASTA - Pack A Subtle Tap Abstraction +# for network namespace/tap device mode +# +# test/build/build.sh - Test build and install targets +# +# Copyright Red Hat +# Author: David Gibson + +import contextlib +import os.path +import shutil +import subprocess +import tempfile + +import exeter + + +def host_run(*cmd, **kwargs): + return subprocess.run(cmd, check=True, encoding='UTF-8', **kwargs) + + +def host_out(*cmd, **kwargs): + return host_run(*cmd, capture_output=True, **kwargs).stdout + + +@contextlib.contextmanager +def clone_source_tree(): + with tempfile.TemporaryDirectory(ignore_cleanup_errors=False) as tmpdir: + # Make a temporary copy of the sources + srcfiles = host_out('git', 'ls-files').splitlines() + for src in srcfiles: + dst = os.path.join(tmpdir, src) + os.makedirs(os.path.dirname(dst), exist_ok=True) + shutil.copy(src, dst) + os.chdir(tmpdir) + yield tmpdir + + +def build_target(target, outputs): + with clone_source_tree(): + for o in outputs: + assert not os.path.exists(o) + host_run('make', f'{target}', 'CFLAGS="-Werror"') + for o in outputs: + assert os.path.exists(o) + host_run('make', 'clean') + for o in outputs: + assert not os.path.exists(o) + + +@exeter.test +def test_make_passt(): + build_target('passt', ['passt']) + + +@exeter.test +def test_make_pasta(): + build_target('pasta', ['pasta']) + + +@exeter.test +def test_make_qrap(): + build_target('qrap', ['qrap']) + + +@exeter.test +def test_make_all(): + build_target('all', ['passt', 'pasta', 'qrap']) + + +@exeter.test +def test_make_install_uninstall(): + with clone_source_tree(): + with tempfile.TemporaryDirectory(ignore_cleanup_errors=False) \ + as prefix: + bindir = os.path.join(prefix, 'bin') + mandir = os.path.join(prefix, 'share', 'man') + exes = ['passt', 'pasta', 'qrap'] + + # Install + host_run('make', 'install', 'CFLAGS="-Werror"', f'prefix={prefix}') + + for t in exes: + assert os.path.isfile(os.path.join(bindir, t)) + host_run('man', '-M', f'{mandir}', '-W', 'passt') + + # Uninstall + host_run('make', 'uninstall', f'prefix={prefix}') + + for t in exes: + assert not os.path.exists(os.path.join(bindir, t)) + cmd = ['man', '-M', f'{mandir}', '-W', 'passt'] + exeter.assert_raises(subprocess.CalledProcessError, + host_run, *cmd) + + +if __name__ == '__main__': + exeter.main() diff --git a/test/run_avocado b/test/run_avocado index d518b9ec..26a226ce 100755 --- a/test/run_avocado +++ b/test/run_avocado @@ -41,7 +41,7 @@ def main(): "resolver.references": references, "runner.identifier_format": "{args}", } - suite = TestSuite.from_config(config, name="static_checkers") + suite = TestSuite.from_config(config, name="all") with Job(config, [suite]) as j: return j.run() -- 2.45.2

We use both cppcheck and clang-tidy to lint our C code. Now that we're introducing Python code in the tests, use linters pycodestyle and flake8. Add a "make meta" target to run tests of the test infrastructure. For now it just has the linters, but we'll add more in future. Signed-off-by: David Gibson --- test/Makefile | 22 +++++++++++++++++++--- test/build/static_checkers.sh | 2 -- test/meta/.gitignore | 1 + test/meta/lint.sh | 28 ++++++++++++++++++++++++++++ test/run_avocado | 5 +++-- 5 files changed, 51 insertions(+), 7 deletions(-) create mode 100644 test/meta/.gitignore create mode 100644 test/meta/lint.sh diff --git a/test/Makefile b/test/Makefile index d24fce14..0b3ed3d0 100644 --- a/test/Makefile +++ b/test/Makefile @@ -6,6 +6,8 @@ # Author: David Gibson WGET = wget -c +FLAKE8 = flake8-3 +PYCODESTYLE = pycodestyle-3 DEBIAN_IMGS = debian-8.11.0-openstack-amd64.qcow2 \ debian-9-nocloud-amd64-daily-20200210-166.qcow2 \ @@ -66,9 +68,13 @@ ASSETS = $(DOWNLOAD_ASSETS) $(LOCAL_ASSETS) EXETER_SH = build/static_checkers.sh EXETER_PY = build/build.py EXETER_JOBS = $(EXETER_SH:%.sh=%.json) $(EXETER_PY:%.py=%.json) - AVOCADO_JOBS = $(EXETER_JOBS) avocado/static_checkers.json +EXETER_META = meta/lint.json +META_JOBS = $(EXETER_META) + +PYPKGS = $(EXETER_PY) + PYTHON = python3 VENV = venv PIP = $(VENV)/bin/pip3 @@ -147,7 +153,17 @@ venv: pull-exeter .PHONY: avocado avocado: venv $(AVOCADO_JOBS) - $(RUN_AVOCADO) $(AVOCADO_JOBS) + $(RUN_AVOCADO) all $(AVOCADO_JOBS) + +.PHONY: meta +meta: venv $(META_JOBS) + $(RUN_AVOCADO) meta $(META_JOBS) + +flake8: + $(FLAKE8) $(PYPKGS) + +pycodestyle: + $(PYCODESTYLE) $(PYPKGS) check: assets ./run @@ -161,7 +177,7 @@ clean: rm -rf test_logs rm -f prepared-*.qcow2 prepared-*.img rm -rf $(VENV) - rm -f $(EXETER_JOBS) + rm -f $(EXETER_JOBS) $(EXETER_META) realclean: clean rm -rf $(DOWNLOAD_ASSETS) diff --git a/test/build/static_checkers.sh b/test/build/static_checkers.sh index ec159ea2..fa07f8fd 100644 --- a/test/build/static_checkers.sh +++ b/test/build/static_checkers.sh @@ -26,5 +26,3 @@ clang_tidy () { exeter_register clang_tidy exeter_main "$@" - - diff --git a/test/meta/.gitignore b/test/meta/.gitignore new file mode 100644 index 00000000..a6c57f5f --- /dev/null +++ b/test/meta/.gitignore @@ -0,0 +1 @@ +*.json diff --git a/test/meta/lint.sh b/test/meta/lint.sh new file mode 100644 index 00000000..6cbaa5d4 --- /dev/null +++ b/test/meta/lint.sh @@ -0,0 +1,28 @@ +#! /bin/sh +# +# SPDX-License-Identifier: GPL-2.0-or-later +# +# PASST - Plug A Simple Socket Transport +# for qemu/UNIX domain socket mode +# +# PASTA - Pack A Subtle Tap Abstraction +# for network namespace/tap device mode +# +# test/meta/lint.sh - Linters for the test code +# +# Copyright Red Hat +# Author: David Gibson + +source $(dirname $0)/../exeter/sh/exeter.sh + +flake8 () { + make -C test flake8 +} +exeter_register flake8 + +pycodestyle () { + make -C test pycodestyle +} +exeter_register pycodestyle + +exeter_main "$@" diff --git a/test/run_avocado b/test/run_avocado index 26a226ce..b62864f6 100755 --- a/test/run_avocado +++ b/test/run_avocado @@ -35,13 +35,14 @@ def main(): os.path.dirname(os.path.dirname(__file__)) ) - references = [os.path.join(repo_root_path, 'test', x) for x in sys.argv[1:]] + suitename = sys.argv[1] + references = [os.path.join(repo_root_path, 'test', x) for x in sys.argv[2:]] config = { "resolver.references": references, "runner.identifier_format": "{args}", } - suite = TestSuite.from_config(config, name="all") + suite = TestSuite.from_config(config, name=suitename) with Job(config, [suite]) as j: return j.run() -- 2.45.2

Add to the tasst library a SimNetHost class used to represent a simulated network host of some type (e.g. namespaces, VMs). For now all it does is lets you execute commands, either foreground or background in the context of the simulated host. We add some "meta" exeter tests for it. Signed-off-by: David Gibson --- test/Makefile | 2 +- test/tasst/__main__.py | 6 +- test/tasst/snh.py | 187 +++++++++++++++++++++++++++++++++++++++++ 3 files changed, 190 insertions(+), 5 deletions(-) create mode 100644 test/tasst/snh.py diff --git a/test/Makefile b/test/Makefile index 81f94f70..8373ae77 100644 --- a/test/Makefile +++ b/test/Makefile @@ -70,7 +70,7 @@ EXETER_PY = build/build.py EXETER_JOBS = $(EXETER_SH:%.sh=%.json) $(EXETER_PY:%.py=%.json) AVOCADO_JOBS = $(EXETER_JOBS) avocado/static_checkers.json -TASST_SRCS = __init__.py __main__.py +TASST_SRCS = __init__.py __main__.py snh.py EXETER_META = meta/lint.json meta/tasst.json META_JOBS = $(EXETER_META) diff --git a/test/tasst/__main__.py b/test/tasst/__main__.py index c365b986..91499128 100644 --- a/test/tasst/__main__.py +++ b/test/tasst/__main__.py @@ -12,10 +12,8 @@ library of test helpers for passt & pasta import exeter - -@exeter.test -def placeholder(): - pass +# We import just to get the exeter tests, which flake8 can't see +from . import snh # noqa: F401 if __name__ == '__main__': diff --git a/test/tasst/snh.py b/test/tasst/snh.py new file mode 100644 index 00000000..dfbe2c84 --- /dev/null +++ b/test/tasst/snh.py @@ -0,0 +1,187 @@ +#! /usr/bin/env python3 + +# SPDX-License-Identifier: GPL-2.0-or-later +# +# Copyright Red Hat +# Author: David Gibson + +""" +Test A Simple Socket Transport + +tasst/snh.py - Simulated network hosts for testing +""" + + +import contextlib +import subprocess +import sys + +import exeter + + +STDOUT = 1 + + +class SnhProcess(contextlib.AbstractContextManager): + """ + A background process running on a SimNetHost + """ + + def __init__(self, snh, *cmd, check=True, context_timeout=1.0, **kwargs): + self.snh = snh + self.cmd = cmd + self.check = check + self.context_timeout = float(context_timeout) + + self.kwargs = kwargs + + def __enter__(self): + self.popen = subprocess.Popen(self.cmd, **self.kwargs) + return self + + def run(self, **kwargs): + stdout, stderr = self.popen.communicate(**kwargs) + cp = subprocess.CompletedProcess(self.popen.args, + self.popen.returncode, + stdout, stderr) + if self.check: + cp.check_returncode() + return cp + + def terminate(self): + self.popen.terminate() + + def kill(self): + self.popen.kill() + + def __exit__(self, *exc_details): + try: + self.popen.wait(timeout=self.context_timeout) + except subprocess.TimeoutExpired as e: + self.terminate() + try: + self.popen.wait(timeout=self.context_timeout) + except subprocess.TimeoutExpired: + self.kill() + raise e + + +class SimNetHost(contextlib.AbstractContextManager): + """ + A (usually virtual or simulated) location where we can execute + commands and configure networks. + + """ + + def __init__(self, name): + self.name = name # For debugging + + def hostify(self, *cmd, **kwargs): + raise NotImplementedError + + def __enter__(self): + return self + + def __exit__(self, *exc_details): + pass + + def output(self, *cmd, **kwargs): + proc = self.fg(*cmd, capture=STDOUT, **kwargs) + return proc.stdout + + def fg(self, *cmd, timeout=None, **kwargs): + # We don't use subprocess.run() because it kills without + # attempting to terminate on timeout + with self.bg(*cmd, **kwargs) as proc: + res = proc.run(timeout=timeout) + return res + + def bg(self, *cmd, capture=None, **kwargs): + if capture == STDOUT: + kwargs['stdout'] = subprocess.PIPE + hostcmd, kwargs = self.hostify(*cmd, **kwargs) + proc = SnhProcess(self, *hostcmd, **kwargs) + print(f"SimNetHost {self.name}: Started {cmd} => {proc}", + file=sys.stderr) + return proc + + # Internal tests + def test_true(self): + with self as snh: + snh.fg('true') + + def test_false(self): + with self as snh: + exeter.assert_raises(subprocess.CalledProcessError, + snh.fg, 'false') + + def test_echo(self): + msg = 'Hello tasst' + with self as snh: + out = snh.output('echo', f'{msg}') + exeter.assert_eq(out, msg.encode('utf-8') + b'\n') + + def test_timeout(self): + with self as snh: + exeter.assert_raises(subprocess.TimeoutExpired, snh.fg, + 'sleep', 'infinity', timeout=0.1, check=False) + + def test_bg_true(self): + with self as snh: + with snh.bg('true'): + pass + + def test_bg_false(self): + with self as snh: + with snh.bg('false') as proc: + exeter.assert_raises(subprocess.CalledProcessError, proc.run) + + def test_bg_echo(self): + msg = 'Hello tasst' + with self as snh: + with snh.bg('echo', f'{msg}', capture=STDOUT) as proc: + res = proc.run() + exeter.assert_eq(res.stdout, msg.encode('utf-8') + b'\n') + + def test_bg_timeout(self): + with self as snh: + with snh.bg('sleep', 'infinity') as proc: + exeter.assert_raises(subprocess.TimeoutExpired, + proc.run, timeout=0.1) + proc.terminate() + + def test_bg_context_timeout(self): + with self as snh: + def run_timeout(): + with snh.bg('sleep', 'infinity', context_timeout=0.1): + pass + exeter.assert_raises(subprocess.TimeoutExpired, run_timeout) + + SELFTESTS = [test_true, test_false, test_echo, test_timeout, + test_bg_true, test_bg_false, test_bg_echo, test_bg_timeout, + test_bg_context_timeout] + + @classmethod + def selftest(cls, setup): + "Register standard snh tests for instance returned by setup" + for t in cls.SELFTESTS: + testid = f'{setup.__qualname__}|{t.__qualname__}' + exeter.register_pipe(testid, setup, t) + + +class RealHost(SimNetHost): + """Represents the host on which the tests are running (as opposed + to some simulated host created by the tests) + + """ + + def __init__(self): + super().__init__('REAL_HOST') + + def hostify(self, *cmd, capable=False, **kwargs): + assert not capable, \ + "BUG: Shouldn't run commands with capabilities on host" + return cmd, kwargs + + +SimNetHost.selftest(RealHost) -- 2.45.2

Use our existing nstool C helper, add python wrappers to easily run commands in various namespaces. Signed-off-by: David Gibson --- test/Makefile | 8 +- test/tasst/__main__.py | 2 +- test/tasst/nstool.py | 170 +++++++++++++++++++++++++++++++++++++++++ test/tasst/snh.py | 16 ++++ 4 files changed, 192 insertions(+), 4 deletions(-) create mode 100644 test/tasst/nstool.py diff --git a/test/Makefile b/test/Makefile index 8373ae77..83725f59 100644 --- a/test/Makefile +++ b/test/Makefile @@ -64,13 +64,15 @@ LOCAL_ASSETS = mbuto.img mbuto.mem.img podman/bin/podman QEMU_EFI.fd \ $(TESTDATA_ASSETS) ASSETS = $(DOWNLOAD_ASSETS) $(LOCAL_ASSETS) +AVOCADO_ASSETS = +META_ASSETS = nstool EXETER_SH = build/static_checkers.sh EXETER_PY = build/build.py EXETER_JOBS = $(EXETER_SH:%.sh=%.json) $(EXETER_PY:%.py=%.json) AVOCADO_JOBS = $(EXETER_JOBS) avocado/static_checkers.json -TASST_SRCS = __init__.py __main__.py snh.py +TASST_SRCS = __init__.py __main__.py nstool.py snh.py EXETER_META = meta/lint.json meta/tasst.json META_JOBS = $(EXETER_META) @@ -157,11 +159,11 @@ meta/tasst.json: $(TASST_SRCS:%=tasst/%) $(VENV) pull-exeter cd ..; PYTHONPATH=$(PYPATH_BASE) $(PYTHON) -m tasst --avocado > test/$@ .PHONY: avocado -avocado: venv $(AVOCADO_JOBS) +avocado: venv $(AVOCADO_ASSETS) $(AVOCADO_JOBS) $(RUN_AVOCADO) all $(AVOCADO_JOBS) .PHONY: meta -meta: venv $(META_JOBS) +meta: venv $(META_ASSETS) $(META_JOBS) $(RUN_AVOCADO) meta $(META_JOBS) flake8: diff --git a/test/tasst/__main__.py b/test/tasst/__main__.py index 91499128..9fd6174e 100644 --- a/test/tasst/__main__.py +++ b/test/tasst/__main__.py @@ -13,7 +13,7 @@ library of test helpers for passt & pasta import exeter # We import just to get the exeter tests, which flake8 can't see -from . import snh # noqa: F401 +from . import nstool, snh # noqa: F401 if __name__ == '__main__': diff --git a/test/tasst/nstool.py b/test/tasst/nstool.py new file mode 100644 index 00000000..0b23fbfb --- /dev/null +++ b/test/tasst/nstool.py @@ -0,0 +1,170 @@ +#! /usr/bin/env python3 + +# SPDX-License-Identifier: GPL-2.0-or-later +# +# Copyright Red Hat +# Author: David Gibson + +""" +Test A Simple Socket Transport + +nstool.py - Run commands in namespaces via 'nstool' +""" + +import contextlib +import os +import subprocess +import tempfile + +import exeter + +from .snh import RealHost, SimNetHost + +# FIXME: Can this be made more portable? +UNIX_PATH_MAX = 108 + +NSTOOL_BIN = 'test/nstool' + + +class NsTool(SimNetHost): + """A bundle of Linux namespaces managed by nstool""" + + def __init__(self, name, sockpath, parent=RealHost()): + if len(sockpath) > UNIX_PATH_MAX: + raise ValueError( + f'Unix domain socket path "{sockpath}" is too long' + ) + + super().__init__(name) + self.sockpath = sockpath + self.parent = parent + self._pid = None + + def __enter__(self): + cmd = [f'{NSTOOL_BIN}', 'info', '-wp', f'{self.sockpath}'] + pid = self.parent.output(*cmd, timeout=1) + self._pid = int(pid) + return self + + def __exit__(self, *exc_details): + pass + + # PID of the nstool hold process as seen by the parent snh + def pid(self): + return self._pid + + # PID of the nstool hold process as seen by another snh which can + # see the nstool socket (important when using PID namespaces) + def relative_pid(self, relative_to): + cmd = [f'{NSTOOL_BIN}', 'info', '-p', f'{self.sockpath}'] + relpid = relative_to.output(*cmd) + return int(relpid) + + def hostify(self, *cmd, capable=False, **kwargs): + hostcmd = [f'{NSTOOL_BIN}', 'exec'] + if capable: + hostcmd.append('--keep-caps') + hostcmd += [self.sockpath, '--'] + hostcmd += list(cmd) + return hostcmd, kwargs + + +@contextlib.contextmanager +def unshare_snh(name, *opts, parent=RealHost(), capable=False): + # Create path for temporary nstool Unix socket + with tempfile.TemporaryDirectory() as tmpd: + sockpath = os.path.join(tmpd, name) + cmd = ['unshare'] + list(opts) + cmd += ['--', f'{NSTOOL_BIN}', 'hold', f'{sockpath}'] + with parent.bg(*cmd, capable=capable) as holder: + try: + with NsTool(name, sockpath, parent=parent) as snh: + yield snh + finally: + try: + parent.fg(f'{NSTOOL_BIN}', 'stop', f'{sockpath}') + finally: + try: + holder.run(timeout=0.1) + holder.kill() + finally: + try: + os.remove(sockpath) + except FileNotFoundError: + pass + + +TEST_EXC = ValueError + + +def test_sockdir_cleanup(s): + def mess(sockpaths): + with s as snh: + ns = snh + while isinstance(ns, NsTool): + sockpaths.append(ns.sockpath) + ns = ns.parent + raise TEST_EXC + + sockpaths = [] + exeter.assert_raises(TEST_EXC, mess, sockpaths) + assert sockpaths + for path in sockpaths: + assert not os.path.exists(os.path.dirname(path)) + + +def userns_snh(): + return unshare_snh('usernetns', '-Ucn') + + +@exeter.test +def test_userns(): + cmd = ['capsh', '--has-p=CAP_SETUID'] + with RealHost() as realhost: + status = realhost.fg(*cmd, check=False) + assert status.returncode != 0 + with userns_snh() as ns: + ns.fg(*cmd, capable=True) + + +@contextlib.contextmanager +def nested_snh(): + with unshare_snh('userns', '-Uc') as userns: + with unshare_snh('netns', '-n', parent=userns, capable=True) as netns: + yield netns + + +def pidns_snh(): + return unshare_snh('pidns', '-Upfn') + + +@exeter.test +def test_relative_pid(): + with pidns_snh() as snh: + # The holder is init (pid 1) within its own pidns + exeter.assert_eq(snh.relative_pid(snh), 1) + + +# General tests for all the nstool examples +for setup in [userns_snh, nested_snh, pidns_snh]: + # Common snh tests + SimNetHost.selftest_isolated(setup) + exeter.register_pipe(f'{setup.__qualname__}|test_sockdir_cleanup', + setup, test_sockdir_cleanup) + + +@contextlib.contextmanager +def connect_snh(): + with tempfile.TemporaryDirectory() as tmpd: + sockpath = os.path.join(tmpd, 'nons') + holdcmd = [f'{NSTOOL_BIN}', 'hold', f'{sockpath}'] + with subprocess.Popen(holdcmd) as holder: + try: + with NsTool("fakens", sockpath) as snh: + yield snh + finally: + holder.kill() + os.remove(sockpath) + + +SimNetHost.selftest(connect_snh) diff --git a/test/tasst/snh.py b/test/tasst/snh.py index 8ee9802a..598ea979 100644 --- a/test/tasst/snh.py +++ b/test/tasst/snh.py @@ -178,6 +178,22 @@ class SimNetHost(contextlib.AbstractContextManager): testid = f'{setup.__qualname__}|{t.__qualname__}' exeter.register_pipe(testid, setup, t) + # Additional tests only valid if the snh is isolated (no outside + # network connections) + def test_is_isolated(self): + with self as snh: + exeter.assert_eq(snh.ifs(), ['lo']) + + ISOLATED_SELFTESTS = [test_is_isolated] + + @classmethod + def selftest_isolated(cls, setup): + "Register self tests for an isolated snh example" + cls.selftest(setup) + for t in cls.ISOLATED_SELFTESTS: + testid = f'{setup.__qualname__}|{t.__qualname__}' + exeter.register_pipe(testid, setup, t) + class RealHost(SimNetHost): """Represents the host on which the tests are running (as opposed -- 2.45.2

Signed-off-by: David Gibson --- test/Makefile | 3 ++- test/tasst/__main__.py | 1 + test/tasst/nstool.py | 9 +++++++++ test/tasst/selftest/__init__.py | 16 ++++++++++++++++ test/tasst/selftest/veth.py | 33 +++++++++++++++++++++++++++++++++ 5 files changed, 61 insertions(+), 1 deletion(-) create mode 100644 test/tasst/selftest/__init__.py create mode 100644 test/tasst/selftest/veth.py diff --git a/test/Makefile b/test/Makefile index 83725f59..e13c49c8 100644 --- a/test/Makefile +++ b/test/Makefile @@ -72,7 +72,8 @@ EXETER_PY = build/build.py EXETER_JOBS = $(EXETER_SH:%.sh=%.json) $(EXETER_PY:%.py=%.json) AVOCADO_JOBS = $(EXETER_JOBS) avocado/static_checkers.json -TASST_SRCS = __init__.py __main__.py nstool.py snh.py +TASST_SRCS = __init__.py __main__.py nstool.py snh.py \ + selftest/__init__.py selftest/veth.py EXETER_META = meta/lint.json meta/tasst.json META_JOBS = $(EXETER_META) diff --git a/test/tasst/__main__.py b/test/tasst/__main__.py index 9fd6174e..d52f9c55 100644 --- a/test/tasst/__main__.py +++ b/test/tasst/__main__.py @@ -14,6 +14,7 @@ import exeter # We import just to get the exeter tests, which flake8 can't see from . import nstool, snh # noqa: F401 +from .selftest import veth # noqa: F401 if __name__ == '__main__': diff --git a/test/tasst/nstool.py b/test/tasst/nstool.py index d852d81e..bf0174eb 100644 --- a/test/tasst/nstool.py +++ b/test/tasst/nstool.py @@ -68,6 +68,15 @@ class NsTool(SimNetHost): hostcmd += list(cmd) return hostcmd, kwargs + def veth(self, ifname, peername, peer=None): + self.fg('ip', 'link', 'add', f'{ifname}', 'type', 'veth', + 'peer', 'name', f'{peername}', capable=True) + if peer is not None: + if not isinstance(peer, NsTool): + raise TypeError + self.fg('ip', 'link', 'set', f'{peername}', + 'netns', f'{peer.relative_pid(self)}', capable=True) + @contextlib.contextmanager def unshare_snh(name, *opts, parent=RealHost(), capable=False): diff --git a/test/tasst/selftest/__init__.py b/test/tasst/selftest/__init__.py new file mode 100644 index 00000000..d7742930 --- /dev/null +++ b/test/tasst/selftest/__init__.py @@ -0,0 +1,16 @@ +#! /usr/bin/python3 + +# SPDX-License-Identifier: GPL-2.0-or-later +# +# Copyright Red Hat +# Author: David Gibson + +"""Test A Simple Socket Transport + +selftest/ - Selftests for the tasst library + +Usually, tests for the tasst helper library itself should go next to +the implementation of the thing being tested. Sometimes that's +inconvenient or impossible (usually because it would cause a circular +module dependency). In that case those tests can go here. +""" diff --git a/test/tasst/selftest/veth.py b/test/tasst/selftest/veth.py new file mode 100644 index 00000000..3c0b3f5b --- /dev/null +++ b/test/tasst/selftest/veth.py @@ -0,0 +1,33 @@ +#! /usr/bin/env python3 + +# SPDX-License-Identifier: GPL-2.0-or-later +# +# Copyright Red Hat +# Author: David Gibson + +""" +Test A Simple Socket Transport + +selftest/veth.py - Test various veth configurations +""" + +import contextlib + +import exeter + +from tasst import nstool + + +@contextlib.contextmanager +def unconfigured_veth(): + with nstool.unshare_snh('ns1', '-Un') as ns1: + with nstool.unshare_snh('ns2', '-n', parent=ns1, capable=True) as ns2: + ns1.veth('veth1', 'veth2', ns2) + yield (ns1, ns2) + + +@exeter.test +def test_ifs(): + with unconfigured_veth() as (ns1, ns2): + exeter.assert_eq(set(ns1.ifs()), set(['lo', 'veth1'])) + exeter.assert_eq(set(ns2.ifs()), set(['lo', 'veth2'])) -- 2.45.2

Add a helper to the Site() class to wait for an address with specified characteristics to be ready on an interface. In particular this is useful for waiting for IPv6 SLAAC & DAD (Duplicate Address Detection) to complete. Because DAD is not going to be useful in many of our scenarios, also extend Site.ifup() to allow DAD to be switched to optimistic mode or disabled. Signed-off-by: David Gibson --- test/Makefile | 2 +- test/tasst/__main__.py | 2 +- test/tasst/selftest/static_ifup.py | 40 ++++++++++++++++++++++++++++++ test/tasst/selftest/veth.py | 27 ++++++++++++++++++++ test/tasst/snh.py | 24 +++++++++++++++++- 5 files changed, 92 insertions(+), 3 deletions(-) create mode 100644 test/tasst/selftest/static_ifup.py diff --git a/test/Makefile b/test/Makefile index e13c49c8..139a0b14 100644 --- a/test/Makefile +++ b/test/Makefile @@ -73,7 +73,7 @@ EXETER_JOBS = $(EXETER_SH:%.sh=%.json) $(EXETER_PY:%.py=%.json) AVOCADO_JOBS = $(EXETER_JOBS) avocado/static_checkers.json TASST_SRCS = __init__.py __main__.py nstool.py snh.py \ - selftest/__init__.py selftest/veth.py + selftest/__init__.py selftest/static_ifup.py selftest/veth.py EXETER_META = meta/lint.json meta/tasst.json META_JOBS = $(EXETER_META) diff --git a/test/tasst/__main__.py b/test/tasst/__main__.py index d52f9c55..f3f88424 100644 --- a/test/tasst/__main__.py +++ b/test/tasst/__main__.py @@ -14,7 +14,7 @@ import exeter # We import just to get the exeter tests, which flake8 can't see from . import nstool, snh # noqa: F401 -from .selftest import veth # noqa: F401 +from .selftest import static_ifup, veth # noqa: F401 if __name__ == '__main__': diff --git a/test/tasst/selftest/static_ifup.py b/test/tasst/selftest/static_ifup.py new file mode 100644 index 00000000..0c6375d4 --- /dev/null +++ b/test/tasst/selftest/static_ifup.py @@ -0,0 +1,40 @@ +#! /usr/bin/env python3 + +# SPDX-License-Identifier: GPL-2.0-or-later +# +# Copyright Red Hat +# Author: David Gibson + +""" +Test A Simple Socket Transport + +meta/static_ifup - Static address configuration +""" + +import contextlib +import ipaddress + +import exeter + +from tasst import nstool + + +IFNAME = 'testveth' +IFNAME_PEER = 'vethpeer' +TEST_IPS = set([ipaddress.ip_interface('192.0.2.1/24'), + ipaddress.ip_interface('2001:db8:9a55::1/112'), + ipaddress.ip_interface('10.1.2.3/8')]) + + +@contextlib.contextmanager +def setup_ns(): + with nstool.unshare_snh('ns', '-Un') as ns: + ns.veth(IFNAME, IFNAME_PEER) + ns.ifup(IFNAME, *TEST_IPS, dad='disable') + yield ns + + +@exeter.test +def test_addr(): + with setup_ns() as ns: + exeter.assert_eq(set(ns.addrs(IFNAME, scope='global')), TEST_IPS) diff --git a/test/tasst/selftest/veth.py b/test/tasst/selftest/veth.py index 5c8f0c0b..24bbdc27 100644 --- a/test/tasst/selftest/veth.py +++ b/test/tasst/selftest/veth.py @@ -12,6 +12,7 @@ selftest/veth.py - Test various veth configurations """ import contextlib +import ipaddress import exeter @@ -38,3 +39,29 @@ def test_mtu(): with unconfigured_veth() as (ns1, ns2): exeter.assert_eq(ns1.mtu('veth1'), 1500) exeter.assert_eq(ns2.mtu('veth2'), 1500) + + +@exeter.test +def test_slaac(dad=None): + TESTMAC = '02:aa:bb:cc:dd:ee' + TESTIP = ipaddress.ip_interface('fe80::aa:bbff:fecc:ddee/64') + + with unconfigured_veth() as (ns1, ns2): + ns1.fg('ip', 'link', 'set', 'dev', 'veth1', 'address', f'{TESTMAC}', + capable=True) + + ns1.ifup('veth1', dad=dad) + ns2.ifup('veth2') + + addrs = ns1.addr_wait('veth1', family='inet6', scope='link') + exeter.assert_eq(addrs, [TESTIP]) + + +@exeter.test +def test_optimistic_dad(): + test_slaac(dad='optimistic') + + +@exeter.test +def test_no_dad(): + test_slaac(dad='disable') diff --git a/test/tasst/snh.py b/test/tasst/snh.py index 0554fbd0..a1225ff0 100644 --- a/test/tasst/snh.py +++ b/test/tasst/snh.py @@ -111,7 +111,23 @@ class SimNetHost(contextlib.AbstractContextManager): info = json.loads(self.output('ip', '-j', 'link', 'show')) return [i['ifname'] for i in info] - def ifup(self, ifname): + def ifup(self, ifname, *addrs, dad=None): + if dad == 'disable': + self.fg('sysctl', f'net.ipv6.conf.{ifname}.accept_dad=0', + capable=True) + elif dad == 'optimistic': + self.fg('sysctl', f'net.ipv6.conf.{ifname}.optimistic_dad=1', + capable=True) + elif dad is not None: + raise ValueError + + for a in addrs: + if not isinstance(a, ipaddress.IPv4Interface) \ + and not isinstance(a, ipaddress.IPv6Interface): + raise TypeError + self.fg('ip', 'addr', 'add', f'{a.with_prefixlen}', + 'dev', f'{ifname}', capable=True) + self.fg('ip', 'link', 'set', f'{ifname}', 'up', capable=True) def addrinfos(self, ifname, **criteria): @@ -135,6 +151,12 @@ class SimNetHost(contextlib.AbstractContextManager): (info,) = json.loads(self.output(*cmd)) return info['mtu'] + def addr_wait(self, ifname, **criteria): + while True: + addrs = self.addrs(ifname, **criteria) + if addrs: + return addrs + # Internal tests def test_true(self): with self as snh: -- 2.45.2

Many of our existing tests are based on using socat to transfer between various locations connected via pasta or passt. Add helpers to make avocado tests performing similar transfers. Add selftests to verify those work as expected when we don't have pasta or passt involved yet. Signed-off-by: David Gibson --- test/Makefile | 4 +- test/tasst/__main__.py | 2 +- test/tasst/transfer.py | 194 +++++++++++++++++++++++++++++++++++++++++ 3 files changed, 197 insertions(+), 3 deletions(-) create mode 100644 test/tasst/transfer.py diff --git a/test/Makefile b/test/Makefile index 139a0b14..584f56e9 100644 --- a/test/Makefile +++ b/test/Makefile @@ -65,14 +65,14 @@ LOCAL_ASSETS = mbuto.img mbuto.mem.img podman/bin/podman QEMU_EFI.fd \ ASSETS = $(DOWNLOAD_ASSETS) $(LOCAL_ASSETS) AVOCADO_ASSETS = -META_ASSETS = nstool +META_ASSETS = nstool small.bin medium.bin big.bin EXETER_SH = build/static_checkers.sh EXETER_PY = build/build.py EXETER_JOBS = $(EXETER_SH:%.sh=%.json) $(EXETER_PY:%.py=%.json) AVOCADO_JOBS = $(EXETER_JOBS) avocado/static_checkers.json -TASST_SRCS = __init__.py __main__.py nstool.py snh.py \ +TASST_SRCS = __init__.py __main__.py nstool.py snh.py transfer.py \ selftest/__init__.py selftest/static_ifup.py selftest/veth.py EXETER_META = meta/lint.json meta/tasst.json diff --git a/test/tasst/__main__.py b/test/tasst/__main__.py index f3f88424..98a94011 100644 --- a/test/tasst/__main__.py +++ b/test/tasst/__main__.py @@ -13,7 +13,7 @@ library of test helpers for passt & pasta import exeter # We import just to get the exeter tests, which flake8 can't see -from . import nstool, snh # noqa: F401 +from . import nstool, snh, transfer # noqa: F401 from .selftest import static_ifup, veth # noqa: F401 diff --git a/test/tasst/transfer.py b/test/tasst/transfer.py new file mode 100644 index 00000000..be3eebc2 --- /dev/null +++ b/test/tasst/transfer.py @@ -0,0 +1,194 @@ +#! /usr/bin/env python3 + +# SPDX-License-Identifier: GPL-2.0-or-later +# +# Copyright Red Hat +# Author: David Gibson + +""" +Test A Simple Socket Transport + +transfer.py - Helpers for testing data transfers +""" + +import contextlib +from ipaddress import IPv4Address, IPv6Address +import time + +import exeter + +from . import nstool, snh + + +# HACK: how long to wait for the server to be ready and listening (s) +SERVER_READY_DELAY = 0.1 # 1/10th of a second + + +# socat needs IPv6 addresses in square brackets +def socat_ip(ip): + if isinstance(ip, IPv6Address): + return f'[{ip}]' + if isinstance(ip, IPv4Address): + return f'{ip}' + raise TypeError + + +def socat_upload(datafile, csnh, ssnh, connect, listen): + srcdata = csnh.output('cat', f'{datafile}') + with ssnh.bg('socat', '-u', f'{listen}', 'STDOUT', + capture=snh.STDOUT) as server: + time.sleep(SERVER_READY_DELAY) + + # Can't use csnh.fg() here, because while we wait for the + # client to complete we won't be reading from the output pipe + # of the server, meaning it will freeze once the buffers fill + with csnh.bg('socat', '-u', f'OPEN:{datafile}', f'{connect}') \ + as client: + res = server.run() + client.run() + exeter.assert_eq(srcdata, res.stdout) + + +def socat_download(datafile, csnh, ssnh, connect, listen): + srcdata = ssnh.output('cat', f'{datafile}') + with ssnh.bg('socat', '-u', f'OPEN:{datafile}', f'{listen}'): + time.sleep(SERVER_READY_DELAY) + dstdata = csnh.output('socat', '-u', f'{connect}', 'STDOUT') + exeter.assert_eq(srcdata, dstdata) + + +def _tcp_socat(connectip, connectport, listenip, listenport, fromip): + v6 = isinstance(connectip, IPv6Address) + if listenport is None: + listenport = connectport + if v6: + connect = f'TCP6:[{connectip}]:{connectport},ipv6only' + listen = f'TCP6-LISTEN:{listenport},ipv6only' + else: + connect = f'TCP4:{connectip}:{connectport}' + listen = f'TCP4-LISTEN:{listenport}' + if listenip is not None: + listen += f',bind={socat_ip(listenip)}' + if fromip is not None: + connect += f',bind={socat_ip(fromip)}' + return (connect, listen) + + +def tcp_upload(datafile, cs, ss, connectip, connectport, + listenip=None, listenport=None, fromip=None): + connect, listen = _tcp_socat(connectip, connectport, listenip, listenport, + fromip) + socat_upload(datafile, cs, ss, connect, listen) + + +def tcp_download(datafile, cs, ss, connectip, connectport, + listenip=None, listenport=None, fromip=None): + connect, listen = _tcp_socat(connectip, connectport, listenip, listenport, + fromip) + socat_download(datafile, cs, ss, connect, listen) + + +def udp_transfer(datafile, cs, ss, connectip, connectport, + listenip=None, listenport=None, fromip=None): + v6 = isinstance(connectip, IPv6Address) + if listenport is None: + listenport = connectport + if v6: + connect = f'UDP6:[{connectip}]:{connectport},ipv6only,shut-null' + listen = f'UDP6-LISTEN:{listenport},ipv6only,null-eof' + else: + connect = f'UDP4:{connectip}:{connectport},shut-null' + listen = f'UDP4-LISTEN:{listenport},null-eof' + if listenip is not None: + listen += f',bind={socat_ip(listenip)}' + if fromip is not None: + connect += f',bind={socat_ip(fromip)}' + + socat_upload(datafile, cs, ss, connect, listen) + + +SMALL_DATA = 'test/small.bin' +BIG_DATA = 'test/big.bin' +UDP_DATA = 'test/medium.bin' + + +class TransferTestScenario: + def __init__(self, *, client, server, connect_ip, connect_port, + listen_ip=None, listen_port=None, from_ip=None): + self.client = client + self.server = server + if isinstance(connect_ip, IPv4Address): + self.ip = connect_ip + self.listen_ip = listen_ip + self.from_ip = from_ip + elif isinstance(connect_ip, IPv6Address): + self.ip = connect_ip + self.listen_ip = listen_ip + self.from_ip = from_ip + self.port = connect_port + self.listen_port = listen_port + + +def test_tcp_upload(setup, datafile=SMALL_DATA): + with setup as scn: + tcp_upload(datafile, scn.client, scn.server, scn.ip, scn.port, + listenip=scn.listen_ip, listenport=scn.listen_port, + fromip=scn.from_ip) + + +def test_tcp_big_upload(setup): + return test_tcp_upload(setup, datafile=BIG_DATA) + + +def test_tcp_download(setup, datafile=SMALL_DATA): + with setup as scn: + tcp_download(datafile, scn.client, scn.server, scn.ip, scn.port, + listenip=scn.listen_ip, listenport=scn.listen_port, + fromip=scn.from_ip) + + +def test_tcp_big_download(setup): + return test_tcp_download(setup, datafile=BIG_DATA) + + +def test_udp_transfer(setup, datafile=UDP_DATA): + with setup as scn: + udp_transfer(datafile, scn.client, scn.server, + scn.ip, scn.port, + listenip=scn.listen_ip, listenport=scn.listen_port, + fromip=scn.from_ip) + + +TRANSFER_TESTS = [test_tcp_upload, test_tcp_big_upload, + test_tcp_download, test_tcp_big_download, + test_udp_transfer] + + +def transfer_tests(setup): + for t in TRANSFER_TESTS: + testid = f'{setup.__qualname__}|{t.__qualname__}' + exeter.register_pipe(testid, setup, t) + + +@contextlib.contextmanager +def local_transfer4(): + with nstool.unshare_snh('ns', '-Un') as ns: + ns.ifup('lo') + yield TransferTestScenario(client=ns, server=ns, + connect_ip=IPv4Address('127.0.0.1'), + connect_port=10000) + + +transfer_tests(local_transfer4) + + +@contextlib.contextmanager +def local_transfer6(): + with nstool.unshare_snh('ns', '-Un') as ns: + ns.ifup('lo') + yield TransferTestScenario(client=ns, server=ns, + connect_ip=IPv6Address('::1'), + connect_port=10000) + + +transfer_tests(local_transfer6) -- 2.45.2

Signed-iff-by: David Gibson --- test/Makefile | 3 +- test/tasst/__main__.py | 2 +- test/tasst/ndp.py | 116 +++++++++++++++++++++++++++++++++++++++++ 3 files changed, 119 insertions(+), 2 deletions(-) create mode 100644 test/tasst/ndp.py diff --git a/test/Makefile b/test/Makefile index f3a3cc58..248329e5 100644 --- a/test/Makefile +++ b/test/Makefile @@ -72,7 +72,8 @@ EXETER_PY = build/build.py EXETER_JOBS = $(EXETER_SH:%.sh=%.json) $(EXETER_PY:%.py=%.json) AVOCADO_JOBS = $(EXETER_JOBS) avocado/static_checkers.json -TASST_SRCS = __init__.py __main__.py address.py nstool.py snh.py transfer.py \ +TASST_SRCS = __init__.py __main__.py address.py ndp.py nstool.py snh.py \ + transfer.py \ selftest/__init__.py selftest/static_ifup.py selftest/veth.py EXETER_META = meta/lint.json meta/tasst.json diff --git a/test/tasst/__main__.py b/test/tasst/__main__.py index 98a94011..6a95eec1 100644 --- a/test/tasst/__main__.py +++ b/test/tasst/__main__.py @@ -13,7 +13,7 @@ library of test helpers for passt & pasta import exeter # We import just to get the exeter tests, which flake8 can't see -from . import nstool, snh, transfer # noqa: F401 +from . import ndp, nstool, snh, transfer # noqa: F401 from .selftest import static_ifup, veth # noqa: F401 diff --git a/test/tasst/ndp.py b/test/tasst/ndp.py new file mode 100644 index 00000000..1c18385c --- /dev/null +++ b/test/tasst/ndp.py @@ -0,0 +1,116 @@ +#! /usr/bin/env avocado-runner-avocado-classless + +# SPDX-License-Identifier: GPL-2.0-or-later +# +# Copyright Red Hat +# Author: David Gibson + +""" +Test A Simple Socket Transport + +ndp.py - Helpers for testing NDP +""" + +import contextlib +import ipaddress +import os +import tempfile + +import exeter + +from . import address, nstool + + +class NdpTestScenario: + def __init__(self, *, client, ifname, network, gateway): + self.client = client + self.ifname = ifname + self.network = network + self.gateway = gateway + + +def test_ndp_addr(setup): + with setup as scn: + # Wait for NDP to do its thing + (addr,) = scn.client.addr_wait(scn.ifname, family='inet6', + scope='global') + + # The SLAAC address is derived from the guest ns MAC, so + # probably won't exactly match the host address (we need + # DHCPv6 for that). It should be in the right network though. + exeter.assert_eq(addr.network, scn.network) + + +def test_ndp_route(setup): + with setup as scn: + defroutes = scn.client.routes6(dst='default') + while not defroutes: + defroutes = scn.client.routes6(dst='default') + + exeter.assert_eq(len(defroutes), 1) + gw = ipaddress.ip_address(defroutes[0]['gateway']) + exeter.assert_eq(gw, scn.gateway) + + +NDP_TESTS = [test_ndp_addr, test_ndp_route] + + +def ndp_tests(setup): + for t in NDP_TESTS: + testid = f'{setup.__qualname__}|{t.__qualname__}' + exeter.register_pipe(testid, setup, t) + + +IFNAME = 'clientif' +NETWORK = address.TEST_NET6_TASST_A +ipa = address.IpiAllocator(NETWORK) +(ROUTER_IP6,) = ipa.next_ipis() + + +@contextlib.contextmanager +def setup_radvd(): + router_ifname = 'routerif' + + with nstool.unshare_snh('client', '-Un') as client, \ + nstool.unshare_snh('router', '-n', + parent=client, capable=True) as router: + with tempfile.TemporaryDirectory() as tmpdir: + client.veth(IFNAME, router_ifname, router) + + # Configure the simulated router + confpath = os.path.join(tmpdir, 'radvd.conf') + pidfile = os.path.join(tmpdir, 'radvd.pid') + open(confpath, 'w', encoding='UTF-8').write( + f''' + interface {router_ifname} {{ + AdvSendAdvert on; + prefix {NETWORK} {{ + }}; + }}; + ''' + ) + + router.ifup('lo') + router.ifup('routerif', ROUTER_IP6) + + # Configure the client + client.ifup('lo') + client.ifup(IFNAME) + + # Get the router's link-local-address + (router_ll,) = router.addr_wait(router_ifname, + family='inet6', scope='link') + + # Run radvd + router.fg('radvd', '-c', '-C', f'{confpath}') + radvd_cmd = ['radvd', '-C', f'{confpath}', '-n', + '-p', f'{pidfile}', '-d', '5'] + with router.bg(*radvd_cmd, capable=True) as radvd: + yield NdpTestScenario(client=client, + ifname=IFNAME, + network=NETWORK, + gateway=router_ll.ip) + radvd.terminate() + + +ndp_tests(setup_radvd) -- 2.45.2

This constructs essentially the simplest sensible network for passt/pasta to operate in. We have one netns "simhost" to represent the host where we will run passt or pasta, and a second "gw" to represent its default gateway. Signed-off-by: David Gibson --- test/Makefile | 3 +- test/tasst/__main__.py | 1 + test/tasst/scenario/__init__.py | 12 ++++ test/tasst/scenario/simple.py | 109 ++++++++++++++++++++++++++++++++ 4 files changed, 124 insertions(+), 1 deletion(-) create mode 100644 test/tasst/scenario/__init__.py create mode 100644 test/tasst/scenario/simple.py diff --git a/test/Makefile b/test/Makefile index 0eeaf82e..6748d38a 100644 --- a/test/Makefile +++ b/test/Makefile @@ -74,7 +74,8 @@ AVOCADO_JOBS = $(EXETER_JOBS) avocado/static_checkers.json TASST_SRCS = __init__.py __main__.py address.py dhcp.py dhcpv6.py ndp.py \ nstool.py snh.py transfer.py \ - selftest/__init__.py selftest/static_ifup.py selftest/veth.py + selftest/__init__.py selftest/static_ifup.py selftest/veth.py \ + scenario/__init__.py scenario/simple.py EXETER_META = meta/lint.json meta/tasst.json META_JOBS = $(EXETER_META) diff --git a/test/tasst/__main__.py b/test/tasst/__main__.py index 8c4efd74..491c68c9 100644 --- a/test/tasst/__main__.py +++ b/test/tasst/__main__.py @@ -14,6 +14,7 @@ import exeter # We import just to get the exeter tests, which flake8 can't see from . import dhcp, dhcpv6, ndp, nstool, snh, transfer # noqa: F401 +from .scenario import simple # noqa: F401 from .selftest import static_ifup, veth # noqa: F401 diff --git a/test/tasst/scenario/__init__.py b/test/tasst/scenario/__init__.py new file mode 100644 index 00000000..4ea4584d --- /dev/null +++ b/test/tasst/scenario/__init__.py @@ -0,0 +1,12 @@ +#! /usr/bin/python3 + +# SPDX-License-Identifier: GPL-2.0-or-later +# +# Copyright Red Hat +# Author: David Gibson + +""" +Test A Simple Socket Transport + +scenario/ - Helpers to set up various sample network topologies +""" diff --git a/test/tasst/scenario/simple.py b/test/tasst/scenario/simple.py new file mode 100644 index 00000000..d8b78568 --- /dev/null +++ b/test/tasst/scenario/simple.py @@ -0,0 +1,109 @@ +#! /usr/bin/env python3 + +# SPDX-License-Identifier: GPL-2.0-or-later +# +# Copyright Red Hat +# Author: David Gibson + +""" +Test A Simple Socket Transport + +scenario/simple.py - Smallest sensible network to use passt/pasta +""" + +import contextlib + +from .. import address, nstool, transfer + + +class __SimpleNet: # pylint: disable=R0903 + """A simple network setup scenario + + The sample network has 2 snhs (network namespaces) connected with + a veth link: + [simhost] <-veth-> [gw] + + gw is set up as the default router for simhost. + + simhost has addresses: + self.IP4 (IPv4), self.IP6 (IPv6), self.ip6_ll (IPv6 link local) + + gw has addresses: + self.GW_IP4 (IPv4), self.GW_IP6 (IPv6), + self.gw_ip6_ll (IPv6 link local) + self.REMOTE_IP4 (IPv4), self.REMOTE_IP6 (IPv6) + + The "remote" addresses are on a different subnet from the others, + so the only way for simhost to reach them is via its default + route. This helps to exercise that we're actually using that, + rather than just local net routes. + + """ + + IFNAME = 'veth' + ipa_local = address.IpiAllocator() + (IP4, IP6) = ipa_local.next_ipis() + (GW_IP4, GW_IP6) = ipa_local.next_ipis() + + ipa_remote = address.IpiAllocator(address.TEST_NET_2, + address.TEST_NET6_TASST_B) + (REMOTE_IP4, REMOTE_IP6) = ipa_remote.next_ipis() + + def __init__(self, simhost, gw): + self.simhost = simhost + self.gw = gw + + ifname = self.IFNAME + self.gw_ifname = 'gw' + ifname + self.simhost.veth(self.IFNAME, self.gw_ifname, self.gw) + + self.gw.ifup('lo') + self.gw.ifup(self.gw_ifname, self.GW_IP4, self.GW_IP6, + self.REMOTE_IP4, self.REMOTE_IP6) + + self.simhost.ifup('lo') + self.simhost.ifup(ifname, self.IP4, self.IP6) + + # Once link is up on both sides, SLAAC will run + self.gw_ip6_ll = self.gw.addr_wait(self.gw_ifname, + family='inet6', scope='link')[0] + self.ip6_ll = self.simhost.addr_wait(ifname, + family='inet6', scope='link')[0] + + # Set up the default route + self.simhost.fg('ip', '-4', 'route', 'add', 'default', + 'via', f'{self.GW_IP4.ip}', capable=True) + self.simhost.fg('ip', '-6', 'route', 'add', 'default', + 'via', f'{self.gw_ip6_ll.ip}', 'dev', f'{ifname}', + capable=True) + + +@contextlib.contextmanager +def simple_net(): + with nstool.unshare_snh('simhost', '-Ucnpf', '--mount-proc') as simhost, \ + nstool.unshare_snh('gw', '-n', parent=simhost, capable=True) as gw: + yield __SimpleNet(simhost, gw) + + +@contextlib.contextmanager +def simple_transfer4_setup(): + with simple_net() as snet: + yield transfer.TransferTestScenario(client=snet.simhost, + server=snet.gw, + connect_ip=snet.REMOTE_IP4.ip, + connect_port=10000) + + +transfer.transfer_tests(simple_transfer4_setup) + + +@contextlib.contextmanager +def simple_transfer6_setup(): + with simple_net() as snet: + yield transfer.TransferTestScenario(client=snet.simhost, + server=snet.gw, + connect_ip=snet.REMOTE_IP6.ip, + connect_port=10000) + + +transfer.transfer_tests(simple_transfer6_setup) -- 2.45.2