atex 0.7__py3-none-any.whl → 0.9__py3-none-any.whl

atex/minitmt/executor.py

@@ -1,348 +0,0 @@
-import os
-import re
-import time
-import select
-import threading
-import contextlib
-import subprocess
-
-from .. import util
-from . import testcontrol, scripts, fmf
-
-
-class Duration:
-    """
-    A helper for parsing, keeping and manipulating test run time based on
-    FMF-defined 'duration' attribute.
-    """
-
-    def __init__(self, fmf_duration):
-        """
-        'fmf_duration' is the string specified as 'duration' in FMF metadata.
-        """
-        duration = self._fmf_to_seconds(fmf_duration)
-        self.end = time.monotonic() + duration
-        # keep track of only the first 'save' and the last 'restore',
-        # ignore any nested ones (as tracked by '_count')
-        self.saved = None
-        self.saved_count = 0
-
-    @staticmethod
-    def _fmf_to_seconds(string):
-        match = re.fullmatch(r"([0-9]+)([a-z]*)", string)
-        if not match:
-            raise RuntimeError(f"'duration' has invalid format: {string}")
-        length, unit = match.groups()
-        if unit == "m":
-            return int(length)*60
-        elif unit == "h":
-            return int(length)*60*60
-        elif unit == "d":
-            return int(length)*60*60*24
-        else:
-            return int(length)
-
-    def set(self, to):
-        self.end = time.monotonic() + self._fmf_to_seconds(to)
-
-    def increment(self, by):
-        self.end += self._fmf_to_seconds(by)
-
-    def decrement(self, by):
-        self.end -= self._fmf_to_seconds(by)
-
-    def save(self):
-        if self.saved_count == 0:
-            self.saved = self.end - time.monotonic()
-        self.saved_count += 1
-
-    def restore(self):
-        if self.saved_count > 1:
-            self.saved_count -= 1
-        elif self.saved_count == 1:
-            self.end = time.monotonic() + self.saved
-            self.saved_count = 0
-            self.saved = None
-
-    def out_of_time(self):
-        return time.monotonic() > self.end
-
-
-# SETUP global:
-# - create CSVAggregator instance on some destination dir
-
-# SETUP of new Provisioner instance:
-# - with SSHConn
-#   - rsync test repo to some tmpdir on the remote
-#   - install packages from plan
-#   - create TMT_PLAN_ENVIRONMENT_FILE and export it to plan setup scripts
-#   - run plan setup scripts
-
-# SETUP + CLEANUP for one test
-# - create Executor instance
-#   - pass TMT_PLAN_ENVIRONMENT_FILE to it
-#     - probably as general "environment variables" input,
-#       could be reused in the future for ie. TMT_PLAN_NAME or so
-#     - pass env from CLI -e switches
-#   - pass disconnected SSHConn to it
-#   - pass one FMFTest namedtuple to it (test to run)
-#   - pass test repo location on the remote host
-#   - pass CSVAggregator instance to it, so it can write results/logs
-# - with SSHConn
-#   - create wrapper script on the remote
-#   - run wrapper script, redirecting stderr to tmpfile via CSVAggregator
-#   - poll() / select() over test stdout, parse TEST_CONTROL protocol
-#   - on 0.1sec poll timeout
-#     - check if SSHConn master is alive, re-connect if not
-#     - check test duration against fmf-defined (control-adjusted) duration
-#   - ...
-# - make Executor return some complex status
-#   - whether testing was destructive (just leave SSHConn disconnected?)
-
-
-class TestAbortedError(Exception):
-    """
-    Raised when an infrastructure-related issue happened while running a test.
-    """
-    pass
-
-
-# TODO: automatic reporting of all partial results that were not finished
-class Executor:
-    """
-    Logic for running tests on a remote system and processing results
-    and uploaded files by those tests.
-    """
-
-    def __init__(self, remote, aggregator, remote_dir=None, env=None):
-        """
-        'remote' is a reserved class Remote instance, with an active connection.
-
-        'aggregator' is an instance of a ResultAggregator all the results
-        and uploaded files will be written to.
-
-        'remote_dir' is a path on the remote for storing tests and other
-        metadata. If unspecified, a tmpdir is created and used instead.
-
-        'env' is a dict of extra environment variables to pass to the
-        plan prepare scripts and tests.
-        """
-        self.lock = threading.RLock()
-        self.remote = remote
-        self.aggregator = aggregator
-        self.cancelled = False
-        self.remote_dir = remote_dir
-        self.plan_env = env.copy() if env else {}
-
-    def _get_remote_dir(self):
-        # TODO: do not mktemp here, do it in the parent, have remote_dir be mandatory,
-        #       renamed to 'tests_dir' (just the test repo), cleaned up by external logic
-        #       - handle custom metadata remote dir in run_test() and clean it up there
-        #         (for TMT_PLAN_ENVIRONMENT_FILE, wrapper, etc.)
-        if not self.remote_dir:
-            self.remote_dir = self.remote.cmd(
-                ("mktemp", "-d", "-p", "/var/tmp"),
-                func=util.subprocess_output,
-            )
-        return self.remote_dir
-
-    # TODO: do not do this in Executor
-    def upload_tests(self, tests_dir):
-        """
-        Upload a directory of all tests from a local 'tests_dir' path to
-        a temporary directory on the remote host.
-        """
-        remote_dir = self._get_remote_dir()
-        self.remote.rsync(
-            "-rv", "--delete", "--exclude=.git/",
-            f"{tests_dir}/",
-            f"remote:{remote_dir}/tests",
-        )
-
-    def setup_plan(self, fmf_tests):
-        """
-        Install packages and run scripts, presumably extracted from a TMT plan
-        provided as 'fmf_tests', an initialized FMFTests instance.
-
-        Also prepare additional environment for tests, ie. create and export
-        a path to TMT_PLAN_ENVIRONMENT_FILE.
-        """
-        # install packages from the plan
-        if fmf_tests.prepare_pkgs:
-            self.remote.cmd(
-                (
-                    "dnf", "-y", "--setopt=install_weak_deps=False",
-                    "install", *fmf_tests.prepare_pkgs,
-                ),
-                check=True,
-            )
-
-        # create TMT_PLAN_ENVIRONMENT_FILE
-        self.plan_env.update(fmf_tests.plan_env)
-        env_file = f"{self._get_remote_dir()}/TMT_PLAN_ENVIRONMENT_FILE"
-        self.remote.cmd(("truncate", "-s", "0", env_file), check=True)
-        self.plan_env["TMT_PLAN_ENVIRONMENT_FILE"] = env_file
-
-        # run prepare scripts
-        env_args = (f"{k}={v}" for k, v in self.plan_env.items())
-        for script in fmf_tests.prepare_scripts:
-            self.remote.cmd(
-                ("env", *env_args, "bash"),
-                input=script,
-                text=True,
-                check=True,
-            )
-
-    def run_test(self, fmf_test, env=None):
-        """
-        Run one test on the remote system.
-
-        'fmf_test' is a FMFTest namedtuple with the test to run.
-
-        'env' is a dict of extra environment variables to pass to the test.
-        """
-        env_vars = self.plan_env.copy()
-        for item in fmf.listlike(fmf_test.data, "environment"):
-            env_vars.update(item)
-        env_vars["ATEX_TEST_NAME"] = fmf_test.name
-        env_vars["TMT_TEST_NAME"] = fmf_test.name
-        if env:
-            env_vars.update(env)
-        env_args = (f"{k}={v}" for k, v in env_vars.items())
-
-        # run a setup script, preparing wrapper + test scripts
-        remote_dir = self._get_remote_dir()
-        setup_script = scripts.test_setup(
-            test=fmf_test,
-            tests_dir=f"{remote_dir}/tests",
-            wrapper_exec=f"{remote_dir}/wrapper.sh",
-            test_exec=f"{remote_dir}/test.sh",
-            debug=True,
-        )
-        self.remote.cmd(("bash",), input=setup_script, text=True, check=True)
-
-        with contextlib.ExitStack() as stack:
-            testout_fd = stack.enter_context(self.aggregator.open_tmpfile())
-
-            duration = Duration(fmf_test.data.get("duration", "5m"))
-
-            test_proc = None
-            control_fd = None
-            stack.callback(lambda: os.close(control_fd) if control_fd else None)
-
-            def abort(msg):
-                if test_proc:
-                    test_proc.kill()
-                    test_proc.wait()
-                self.remote.release()
-                raise TestAbortedError(msg) from None
-
-            try:
-                # TODO: probably enum
-                state = "starting_test"
-                while not duration.out_of_time():
-                    with self.lock:
-                        if self.cancelled:
-                            abort("cancel requested")
-                            return
-
-                    if state == "starting_test":
-                        control_fd, pipe_w = os.pipe()
-                        os.set_blocking(control_fd, False)
-                        control = testcontrol.TestControl(
-                            control_fd=control_fd,
-                            aggregator=self.aggregator,
-                            duration=duration,
-                            testout_fd=testout_fd,
-                        )
-                        # run the test in the background, letting it log output directly to
-                        # an opened file (we don't handle it, cmd client sends it to kernel)
-                        test_proc = self.remote.cmd(
-                            ("env", *env_args, f"{remote_dir}/wrapper.sh"),
-                            stdout=pipe_w,
-                            stderr=testout_fd,
-                            func=util.subprocess_Popen,
-                        )
-                        os.close(pipe_w)
-                        state = "reading_control"
-
-                    elif state == "reading_control":
-                        rlist, _, xlist = select.select((control_fd,), (), (control_fd,), 0.1)
-                        if xlist:
-                            abort(f"got exceptional condition on control_fd {control_fd}")
-                        elif rlist:
-                            control.process()
-                            if control.eof:
-                                os.close(control_fd)
-                                control_fd = None
-                                state = "waiting_for_exit"
-
-                    elif state == "waiting_for_exit":
-                        # control stream is EOF and it has nothing for us to read,
-                        # we're now just waiting for proc to cleanly terminate
-                        try:
-                            code = test_proc.wait(0.1)
-                            if code == 0:
-                                # wrapper exited cleanly, testing is done
-                                break
-                            else:
-                                # unexpected error happened (crash, disconnect, etc.)
-                                self.remote.disconnect()
-                                # if reconnect was requested, do so, otherwise abort
-                                if control.reconnect:
-                                    state = "reconnecting"
-                                    if control.reconnect != "always":
-                                        control.reconnect = None
-                                else:
-                                    abort(f"test wrapper unexpectedly exited with {code}")
-                            test_proc = None
-                        except subprocess.TimeoutExpired:
-                            pass
-
-                    elif state == "reconnecting":
-                        try:
-                            self.remote.connect(block=False)
-                            state = "reading_control"
-                        except BlockingIOError:
-                            pass
-
-                    else:
-                        raise AssertionError("reached unexpected state")
-
-                else:
-                    abort("test duration timeout reached")
-
-                # testing successful, do post-testing tasks
-
-                # test wrapper hasn't provided exitcode
-                if control.exit_code is None:
-                    abort("exitcode not reported, wrapper bug?")
-
-                # partial results that were never reported
-                if control.partial_results:
-                    control.result_seen = True  # partial result is also a result
-                    for result in control.partial_results.values():
-                        self.aggregator.report(result)
-
-                # test hasn't reported a single result, add an automatic one
-                # as specified in RESULTS.md
-                # {"status": "pass", "name": "/some/test", "testout": "output.txt"}
-                if not control.result_seen:
-                    self.aggregator.link_tmpfile_to(fmf_test.name, "output.txt", testout_fd)
-                    self.aggregator.report({
-                        "status": "pass" if control.exit_code == 0 else "fail",
-                        "name": fmf_test.name,
-                        "testout": "output.txt",
-                    })
-
-            except Exception:
-                # if the test hasn't reported a single result, but still
-                # managed to break something, provide at least the default log
-                # for manual investigation - otherwise test output disappears
-                if not control.result_seen:
-                    self.aggregator.link_tmpfile_to(fmf_test.name, "output.txt", testout_fd)
-                raise
-
-    def cancel(self):
-        with self.lock:
-            self.cancelled = True

atex/minitmt/fmf.py

@@ -1,202 +0,0 @@
-import re
-import collections
-from pathlib import Path
-
-# from system-wide sys.path
-import fmf
-
-# name: fmf path to the test as string, ie. /some/test
-# data: dict of the parsed fmf metadata (ie. {'tag': ... , 'environment': ...})
-# dir:  relative pathlib.Path of the test .fmf to repo root, ie. some/test
-#       (may be different from name for "virtual" tests that share the same dir)
-FMFTest = collections.namedtuple("FMFTest", ["name", "data", "dir"])
-
-
-def listlike(data, key):
-    """
-    Get a piece of fmf metadata as an iterable regardless of whether it was
-    defined as a dict or a list.
-
-    This is needed because many fmf metadata keys can be used either as
-        some_key: 123
-    or as lists via YAML syntax
-        some_key:
-          - 123
-          - 456
-    and, for simplicity, we want to always deal with lists (iterables).
-    """
-    if value := data.get(key):
-        return value if isinstance(value, list) else (value,)
-    else:
-        return ()
-
-
-class FMFTests:
-    """
-    FMF test metadata parsed from on-disk metadata using a specific plan name,
-    with all metadata dictionaries for all nodes being adjusted by that plan
-    and (optionally) a specified context.
-    """
-    # TODO: usage example ^^^^
-
-    def __init__(self, fmf_tree, plan_name, context=None):
-        """
-        'fmf_tree' is filesystem path somewhere inside fmf metadata tree,
-        or a root fmf.Tree instance.
-
-        'plan_name' is fmf identifier (like /some/thing) of a tmt plan
-        to use for discovering tests.
-
-        'context' is a dict like {'distro': 'rhel-9.6'} used for filtering
-        discovered tests.
-        """
-        # list of packages to install, as extracted from plan
-        self.prepare_pkgs = []
-        # list of scripts to run, as extracted from plan
-        self.prepare_scripts = []
-        # dict of environment, as extracted from plan
-        self.plan_env = {}
-        # dict indexed by test name, value is dict with fmf-parsed metadata
-        self.tests = {}
-        # dict indexed by test name, value is pathlib.Path of relative path
-        # of the fmf metadata root towards the test metadata location
-        self.test_dirs = {}
-
-        tree = fmf_tree.copy() if isinstance(fmf_tree, fmf.Tree) else fmf.Tree(fmf_tree)
-        ctx = fmf.Context(**context) if context else fmf.Context()
-        tree.adjust(context=ctx)
-
-        self.fmf_root = tree.root
-
-        # lookup the plan first
-        plan = tree.find(plan_name)
-        if not plan:
-            raise ValueError(f"plan {plan_name} not found in {tree.root}")
-        if "test" in plan.data:
-            raise ValueError(f"plan {plan_name} appears to be a test")
-
-        # gather and merge plan-defined environment variables
-        #
-        # environment:
-        #  - FOO: BAR
-        #    BAR: BAZ
-        for entry in listlike(plan.data, "environment"):
-            self.plan_env.update(entry)
-
-        # gather all prepare scripts / packages
-        #
-        # prepare:
-        #   - how: install
-        #     package:
-        #       - some-rpm-name
-        #   - how: shell
-        #     script:
-        #       - some-command
-        for entry in listlike(plan.data, "prepare"):
-            if "how" not in entry:
-                continue
-            if entry["how"] == "install":
-                self.prepare_pkgs += listlike(entry, "package")
-            elif entry["how"] == "shell":
-                self.prepare_scripts += listlike(entry, "script")
-
-        # gather all tests selected by the plan
-        #
-        # discover:
-        #   - how: fmf
-        #     filter:
-        #       - tag:some_tag
-        #     test:
-        #       - some-test-regex
-        #     exclude:
-        #       - some-test-regex
-        if "discover" in plan.data:
-            discover = plan.data["discover"]
-            if not isinstance(discover, list):
-                discover = (discover,)
-
-            for entry in discover:
-                if entry.get("how") != "fmf":
-                    continue
-
-                filtering = {}
-                for meta_name in ("filter", "test", "exclude"):
-                    if value := listlike(entry, meta_name):
-                        filtering[meta_name] = value
-
-                children = tree.prune(
-                    names=filtering.get("test"),
-                    filters=filtering.get("filter"),
-                )
-                for child in children:
-                    # excludes not supported by .prune(), we have to do it here
-                    excludes = filtering.get("exclude")
-                    if excludes and any(re.match(x, child.name) for x in excludes):
-                        continue
-                    # only enabled tests
-                    if "enabled" in child.data and not child.data["enabled"]:
-                        continue
-                    # no manual tests and no stories
-                    if child.data.get("manual") or child.data.get("story"):
-                        continue
-                    # after adjusting above, any adjusts are useless, free some space
-                    if "adjust" in child.data:
-                        del child.data["adjust"]
-
-                    self.tests[child.name] = child.data
-                    # child.sources ie. ['/abs/path/to/some.fmf', '/abs/path/to/some/node.fmf']
-                    self.test_dirs[child.name] = \
-                        Path(child.sources[-1]).parent.relative_to(self.fmf_root)
-
-    def as_fmftest(self, name):
-        return FMFTest(name, self.tests[name], self.test_dirs[name])
-
-    def as_fmftests(self):
-        for name, data in self.tests.items():
-            yield FMFTest(name, data, self.test_dirs[name])
-
-    def match(self, regex):
-        """
-        Return an iterable of FMFTest instances with test names matching the
-        specified regex via re.match(), just like how 'tmt' discovers tests.
-        """
-        for name, data in self.tests.items():
-            if re.match(regex, name):
-                yield FMFTest(name, data, self.test_dirs[name])
-
-
-# Some extra notes for fmf.prune() arguments:
-#
-# Set 'names' to filter by a list of fmf node names, ie.
-#     ['/some/test', '/another/test']
-#
-# Set 'filters' to filter by a list of fmf-style filter expressions, see
-#     https://fmf.readthedocs.io/en/stable/modules.html#fmf.filter
-#
-# Set 'conditions' to filter by a list of python expressions whose namespace
-# locals() are set up to be a dictionary of the tree. When any of the
-# expressions returns True, the tree is returned, ie.
-#     ['environment["FOO"] == "BAR"']
-#     ['"enabled" not in locals() or enabled']
-# Note that KeyError is silently ignored and treated as False.
-#
-# Set 'context' to a dictionary to post-process the tree metadata with
-# adjust expressions (that may be present in a tree) using the specified
-# context. Any other filters are applied afterwards to allow modification
-# of tree metadata by the adjust expressions. Ie.
-#     {'distro': 'rhel-9.6.0', 'arch': 'x86_64'}
-
-Platform = collections.namedtuple("Platform", ["distro", "arch"])
-
-
-def combine_platforms(fmf_path, plan_name, platforms):
-    # TODO: document
-    fmf_tests = {}
-    tree = fmf.Tree(fmf_path)
-    for platform in platforms:
-        context = {"distro": platform.distro, "arch": platform.arch}
-        fmf_tests[platform] = FMFTests(tree, plan_name, context=context)
-    return fmf_tests
-
-# TODO: in Orchestrator, when a Provisioner becomes free, have it pick a test
-#       from the appropriate tests[platform] per the Provisioner's platform

atex/provision/nspawn/README

@@ -1,74 +0,0 @@
-The idea is to use systemd-nspawn containers on the host, binding
-/dev/kvm to each, thus avoiding the need for nested virt as our first layer
-of Contest tests will run in the containers (installing libvirtd, etc.)
-and the second layer (VMs created by tests) will use virtual machines,
-via a non-nested HVM.
-
-systemd-nspawn containers can have CPU core limits, memory limits, etc.
-done via cgroups, so we can provide some level of isolation/safety.
-
-
-systemd-nspawn can create its own veth via --network-veth=... and put it into
-a bridge automatically via --network-bridge=...
-
-We can then use NetworkManager + firewalld to pre-create a bridge with built-in
-DHCP and NAT to the outside, via something like
-
-  nmcli connection add type bridge ifname br0 con-name br0 ipv4.method shared ipv6.method ignore
-
-According to https://fedoramagazine.org/internet-connection-sharing-networkmanager/
-the ipv4.method=shared :
-
-    enables IP forwarding for the interface;
-    adds firewall rules and enables masquerading;
-    starts dnsmasq as a DHCP and DNS server.
-
-Specifically it should add MASQUERADE on packets *outgoing* from the bridge subnet,
-so shouldn't need any modification of the upstream eth0 device or any fw rules tied to it.
-
-There also seems to be ipv4.addresses 192.168.42.1/24 to modify the subnet?
-
-If that doesn't work, firewalld has an External zone that has <masquerade/>
-by default, so 
-
-  nmcli connection modify br0 connection.zone external
-
-should work.
-
-
---------
-
-TODO: We need some way to get DHCP leases for started containers (so we can connect
-      to the containerized sshd).
-
-      If there is no command for it via nmcli, it should be possible to just
-      extract it from wherever NetworkManager pointed dnsmasq to store its leases file.
-
-      We can then probably correlate --network-veth=... device from systemd-nspawn
-      (named after --machine=... name, prefixed with ve-* or vb-* if --network-bridge=* is used)
-      to the leased IP address.
-
-      ls -l /var/lib/NetworkManager/dnsmasq-*.leases
-
-      Or perhaps parse it out of 'ip neigh' to make sure the guest is *really* up.
-        - 'ip neigh' gives us MAC-to-IP, but device is always br0
-        - 'ip link show dev vb-contname' should give us the MAC for 'ip neigh'
-          - if container veth endpoint uses different mac, we can query bridge forward DB
-            via 'bridge fdb' to get all MACs that appeared on the veth
-
---------
-
-Containers can be installed via ie.
-
-dnf  --releasever=41 --installroot=/var/lib/machines/f41 --use-host-config \
-     --setopt=install_weak_deps=False \
-     install \
-     passwd dnf fedora-release vim-minimal util-linux systemd NetworkManager
-
-where --use-host-config re-uses host repositories.
-
-Maybe consider 'machinectl'-managed containers (start/terminate/kill/reboot/etc.)
-which are just repackaged systemd-nspawn@ services.
- - Especially since there is no concept of "throw away disk snapshot with container exit",
-   we always need some copy/clone of the --installroot for each instance of the container,
-   so using ie. 'machinectl clone ...' would provide a nice interface for it.

atex/provision/podman/README

@@ -1,59 +0,0 @@
-
-making a podman image from the currently installed OS:
-
-1) dnf install into a separate installroot
-
-dnf
-    --installroot=$INSTALLROOT \
-    --setopt=install_weak_deps=False \
-    --setopt=tsflags=nodocs \
-    -y groupinstall minimal-environment
-
-as root (doesn't work well with unshare, maybe could work via bwrap (bubblewrap))
-
-maybe the unprivileged solution is pulling image from hub + installing @minimal-environment
-into it (perhaps via podman build)
-
-
-2) post process it
-
-echo -n > "$INSTALLROOT/etc/machine-id"
-echo container > "$INSTALLROOT/etc/hostname"
-
-rm -rf "$INSTALLROOT/etc/yum.repos.d"
-cp -f /etc/yum.repos.d/* "$INSTALLROOT/etc/yum.repos.d/."
-cp -f /etc/pki/rpm-gpg/* "$INSTALLROOT/etc/pki/rpm-gpg/."
-
-echo install_weak_deps=False >> "$INSTALLROOT/etc/dnf/dnf.conf"
-echo tsflags=nodocs >> "$INSTALLROOT/etc/dnf/dnf.conf"
-
-ln -sf \
-    /usr/lib/systemd/system/multi-user.target \
-    "$INSTALLROOT/etc/systemd/system/default.target"
-
-# disable auditd
-# disable other services
-# set root password
-
-dnf clean all --installroot="$INSTALLROOT"
-
-
-3) pack it
-
-tar --xattrs -C "$INSTALLROOT" -cvf tarball.tar .
-
-rm -rf "$INSTALLROOT"
-
-
-4) import it to podman
-
-podman import --change 'CMD ["/sbin/init"]' tarball.tar my-image-name
-
-
-5) run it
-
-podman {run,create} --systemd=always --cgroups=split ...
-
-
-
-------------------------------