atex 0.1__py3-none-any.whl

atex/minitmt/report.py

@@ -0,0 +1,174 @@
+import os
+import csv
+import gzip
+import ctypes
+import ctypes.util
+import contextlib
+from pathlib import Path
+
+from .. import util
+
+
+libc = ctypes.CDLL(ctypes.util.find_library('c'))
+
+# int linkat(int olddirfd, const char *oldpath, int newdirfd, const char *newpath, int flags)
+libc.linkat.argtypes = (
+    ctypes.c_int,
+    ctypes.c_char_p,
+    ctypes.c_int,
+    ctypes.c_char_p,
+    ctypes.c_int,
+)
+libc.linkat.restype = ctypes.c_int
+
+# fcntl.h:#define AT_EMPTY_PATH                0x1000  /* Allow empty relative pathname */
+AT_EMPTY_PATH = 0x1000
+
+# fcntl.h:#define AT_FDCWD             -100    /* Special value used to indicate
+AT_FDCWD = -100
+
+
+def linkat(*args):
+    if (ret := libc.linkat(*args)) == -1:
+        errno = ctypes.get_errno()
+        raise OSError(errno, os.strerror(errno))
+    return ret
+
+
+class CSVReporter(util.LockableClass):
+    """
+    Stores reported results as a GZIP-ed CSV and files (logs) under a related
+    directory.
+
+        with CSVReporter('file/storage/dir', 'results.csv.gz') as reporter:
+            sub = reporter.make_subreporter('rhel-9', 'x86_64')
+            sub({'name': '/some/test', 'status': 'pass'})
+            sub({'name': '/another/test', 'status': 'pass'})
+            ...
+            sub = reporter.make_subreporter('rhel-9', 'ppc64le')
+            ...
+            sock = accept_unix_connection()
+            reporter.store_file('/some/test', 'debug.log', sock, 1234)
+    """
+    class _ExcelWithUnixNewline(csv.excel):
+        lineterminator = '\n'
+
+    def __init__(self, storage_dir, results_file):
+        super().__init__()
+        self.storage_dir = Path(storage_dir)
+        if self.storage_dir.exists():
+            raise FileExistsError(f"{storage_dir} already exists")
+        self.results_file = Path(results_file)
+        if self.results_file.exists():
+            raise FileExistsError(f"{self.results_file} already exists")
+        self.storage_dir.mkdir()
+        self.csv_writer = None
+        self.results_gzip_handle = None
+
+    def __enter__(self):
+        f = gzip.open(self.results_file, 'wt', newline='')
+        try:
+            self.csv_writer = csv.writer(f, dialect=self._ExcelWithUnixNewline)
+        except:
+            f.close()
+            raise
+        self.results_gzip_handle = f
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.results_gzip_handle.close()
+        self.results_gzip_handle = None
+        self.csv_writer = None
+
+    def report(self, distro, arch, status, name, note, *files):
+        """
+        Persistently write out details of a test result.
+        """
+        with self.lock:
+            self.csv_writer.writerow((distro, arch, status, name, note, *files))
+
+    @staticmethod
+    def _normalize_path(path):
+        # the magic here is to treat any dangerous path as starting at /
+        # and resolve any weird constructs relative to /, and then simply
+        # strip off the leading / and use it as a relative path
+        path = path.lstrip('/')
+        path = os.path.normpath(f'/{path}')
+        return path[1:]
+
+    def make_subreporter(self, distro, arch):
+        """
+        Return a preconfigured reporter instance, suitable for use
+        by an Executor.
+        """
+        def reporter(result_line):
+            if 'files' in result_line:
+                files = (self._normalize_path(x['name']) for x in result_line['files'])
+            else:
+                files = ()
+            self.report(
+                distro, arch, result_line['status'], result_line['name'],
+                result_line.get('note', ''), *files,
+            )
+        return reporter
+
+    def _files_dir(self, result_name):
+        dir_path = self.storage_dir / result_name.lstrip('/')
+        dir_path.mkdir(parents=True, exist_ok=True)
+        return dir_path
+
+    def _files_file(self, result_name, file_name):
+        file_name = self._normalize_path(file_name)
+        return self._files_dir(result_name) / file_name
+
+    @contextlib.contextmanager
+    def open_tmpfile(self, open_mode=os.O_WRONLY):
+        flags = open_mode | os.O_TMPFILE
+        fd = os.open(self.storage_dir, flags, 0o644)
+        try:
+            yield fd
+        finally:
+            os.close(fd)
+#    def open_tmpfile(self, result_name, open_mode=os.O_WRONLY):
+#        """
+#        Open an anonymous (name-less) file for writing, in a directory relevant
+#        to 'result_name' and yield its file descriptor (int) as context, closing
+#        it when the context is exited.
+#        """
+#        flags = open_mode | os.O_TMPFILE
+#        fd = os.open(self._files_dir(result_name), flags, 0o644)
+#        try:
+#            yield fd
+#        finally:
+#            os.close(fd)
+
+    def link_tmpfile_to(self, result_name, file_name, fd):
+        """
+        Store a file named 'file_name' in a directory relevant to 'result_name'
+        whose 'fd' (a file descriptor) was created by open_tmpfile().
+
+        This function can be called multiple times with the same 'fd', and
+        does not close or otherwise alter the descriptor.
+        """
+        final_path = self._files_file(result_name, file_name)
+        linkat(fd, b'', AT_FDCWD, bytes(final_path), AT_EMPTY_PATH)
+
+    def store_file(self, result_name, file_name, in_fd, count):
+        """
+        Read 'count' bytes of binary data from an OS file descriptor 'in_fd'
+        and store them under 'result_name' as a file (or relative path)
+        named 'file_name', creating it.
+        """
+        final_path = self._files_file(result_name, file_name)
+        # be as efficient as possible, let the kernel handle big data
+        out_fd = None
+        try:
+            out_fd = os.open(final_path, os.O_WRONLY | os.O_CREAT)
+            while count > 0:
+                written = os.sendfile(out_fd, in_fd, None, count)
+                if written == 0:
+                    raise RuntimeError(f"got unexpected EOF when receiving {final_path}")
+                count -= written
+        finally:
+            if out_fd:
+                os.close(out_fd)

atex/minitmt/scripts.py

@@ -0,0 +1,51 @@
+#from .. import util
+
+#run_test = util.dedent(fr'''
+#    # create a temp dir for everything, send it to the controller
+#    tmpdir=$(mktemp -d /var/tmp/atex-XXXXXXXXX)
+#    echo "tmpdir=$tmpdir"
+#
+#    # remove transient files if interrupted
+#    trap "rm -rf \"$tmpdir\"" INT
+#
+#    # wait for result reporting unix socket to be created by sshd
+#    socket=$tmpdir/results.sock
+#    while [[ ! -e $socket ]]; do sleep 0.1; done
+#    echo "socket=$socket"
+#
+#    # tell the controller to start logging test output
+#    echo ---
+#
+#    # install test dependencies
+#    rpms=( {' '.join(requires)} )
+#    to_install=()
+#    for rpm in "${{rpms[@]}}"; do
+#        rpm -q --quiet "$rpm" || to_install+=("$rpm")
+#    done
+#    dnf -y --setopt=install_weak_deps=False install "${{to_install[@]}}"
+#
+#    # run the test
+#    ...
+#    rc=$?
+#
+#    # test finished, clean up
+#    rm -rf "$tmpdir"
+#
+#    exit $rc
+#''')
+
+# TODO: have another version of ^^^^ for re-execution of test after a reboot
+#       or disconnect that sets tmpdir= from us (reusing on-disk test CWD)
+#       rather than creating a new one
+#         - the second script needs to rm -f the unix socket before echoing
+#           something back to let us re-create it via a new ssh channel open
+#           because StreamLocalBindUnlink doesn't seem to work
+
+
+# TODO: call ssh with -oStreamLocalBindUnlink=yes to re-initialize
+#       the listening socket after guest reboot
+#
+#       -R /var/tmp/atex-BlaBla/results.sock:/var/tmp/controller.sock
+#
+#       (make sure to start listening on /var/tmp/controller.sock before
+#        calling ssh to run the test)

atex/minitmt/testme.py

@@ -0,0 +1,3 @@
+from ..util import debug
+
+debug("foo")

atex/orchestrator.py

@@ -0,0 +1,38 @@
+from . import util
+
+
+class Orchestrator:
+    """
+    A scheduler for parallel execution on multiple resources (machines/systems).
+
+    Given a list of Provisioner-derived class instances, it attempts to reserve
+    resources and uses them on-demand as they become available, calling run()
+    on each.
+
+    Note that run() and report() always run in a separate threads (are allowed
+    to block), and may access instance attributes, which are transparently
+    guarded by a thread-aware mutex.
+
+    """
+
+    def __init__(self):
+        pass
+        # TODO: configure via args, max workers, etc.
+
+#    def reserve(self, provisioner):
+#        # call provisioner.reserve(), return its return
+#        ...
+
+    def add_provisioner(self, provisioner):
+        # add to a self.* list of provisioners to be used for getting machines
+        ...
+
+    def run(self, provisioner):
+        # run tests, if destructive, call provisioner.release()
+        # returns anything
+        ...
+
+    def report(self):
+        # gets return from run
+        # writes it out to somewhere else
+        ...

atex/provision/__init__.py

@@ -0,0 +1,113 @@
+import importlib
+import pkgutil
+
+from .. import util
+
+
+class Provisioner(util.LockableClass):
+    """
+    A resource (machine/system) provider.
+
+    Any class derived from Provisioner serves as a mechanisms for requesting
+    a resource (machine/system), waiting for it to be reserved, providing ssh
+    details on how to connect to it, and releasing it when no longer useful.
+
+    The 4 main API points for this are reserve(), connection(), release() and
+    alive().
+    If necessary, these methods can share data via class instance attributes,
+    which are transparently guarded by a thread-aware mutex. For any complex
+    reads/writes, use 'self.lock' via a context manager.
+
+    Note that reserve() always runs in a separate thread (and thus may block),
+    and other functions (incl. release()) may be called at any time from
+    a different thread, even while reserve() is still running.
+    It is thus recommended for reserve() to store metadata in self.* as soon
+    as the metadata becomes available (some job ID, request UUID, Popen proc
+    object with PID, etc.) so that release() can free the resource at any time.
+
+    Once release()'d, the instance is never reused for reserve() again.
+    However connection(), release() and alive() may be called several times at
+    any time and need to handle it safely.
+    Ie. once released(), an instance must never return alive() == True.
+
+        # explicit method calls
+        res = Provisioner(...)
+        res.reserve()
+        conn = res.connection()
+        conn.connect()
+        conn.ssh('ls /')
+        conn.disconnect()
+        res.release()
+
+        # via a context manager
+        with Provisioner(...) as res:
+            with res.connection() as conn:
+                conn.ssh('ls /')
+
+    If a Provisioner class needs additional configuration, it should do so via
+    class (not instance) attributes, allowing it to be instantiated many times.
+
+        class ConfiguredProvisioner(Provisioner):
+            resource_hub = 'https://...'
+            login = 'joe'
+
+        # or dynamically
+        name = 'joe'
+        cls = type(
+            f'Provisioner_for_{name}',
+            (Provisioner,),
+            {'resource_hub': 'https://...', 'login': name},
+        )
+
+    These attributes can then be accessed from __init__ or any other function.
+    """
+
+    def __init__(self):
+        """
+        Initialize the provisioner instance.
+        If extending __init__, always call 'super().__init__()' at the top.
+        """
+        super().__init__()
+
+    def reserve(self):
+        """
+        Send a reservation request for a resource and wait for it to be
+        reserved.
+        """
+        raise NotImplementedError(f"'reserve' not implemented for {self.__class__.__name__}")
+
+    def connection(self):
+        """
+        Return an atex.ssh.SSHConn instance configured for connection to
+        the reserved resource, but not yet connected.
+        """
+        raise NotImplementedError(f"'connection' not implemented for {self.__class__.__name__}")
+
+    def release(self):
+        """
+        Release a reserved resource, or cancel a reservation-in-progress.
+        """
+        raise NotImplementedError(f"'release' not implemented for {self.__class__.__name__}")
+
+    def alive(self):
+        """
+        Return True if the resource is still reserved, False otherwise.
+        """
+        raise NotImplementedError(f"'alive' not implemented for {self.__class__.__name__}")
+
+
+def find_provisioners():
+    provisioners = []
+    for info in pkgutil.iter_modules(__spec__.submodule_search_locations):
+        mod = importlib.import_module(f'.{info.name}', __name__)
+        # look for Provisioner-derived classes in the module
+        for attr in dir(mod):
+            if attr.startswith('_'):
+                continue
+            value = getattr(mod, attr)
+            try:
+                if issubclass(value, Provisioner):
+                    provisioners.append(attr)
+            except TypeError:
+                pass
+    return provisioners

atex/provision/libvirt/VM_PROVISION

@@ -0,0 +1,51 @@
+IMAGED INSTALLS:
+
+- have an independent script to install/prepare an image from install URL / nightly name
+  - could be invoked as a "setup task" by the user
+  - could be run automatically via cron on the VM host, etc.
+  - some script that does virt-install --transient and installs new prepared
+    template images into some pool
+  - use virt-sysprep from guestfs-tools when preparing an image during setup
+
+- have another independent script that pre-creates domains (XMLs) on the VM host
+  - script that (without locking, it should never be run alongside the above)
+    pre-creates domains on the system (specifying various options, etc.)
+    - maybe generating XML directly from given opts?
+    - maybe using virt-install?
+
+- from the many (60+) provision modules:
+  - don't create new libvirt domains from scratch, that's too inefficient remotely
+    - have pre-created persistent domains (see above)
+  - have pre-installed ready-to-use images to be cloned
+    - or otherwise separate the process of installing images from using domains for testing
+  - have some limitation on volume storage for a domain, to make things simpler
+    - (don't deal with path-based image storage, many disks, etc.)
+    - we will ONLY touch volumes in some specified --pool that are named EXACTLY
+      the same as domain names (ie. volume called scap-t12 for scap-t12 domain)
+    - domains can have many other disks/sources/volumes, we don't care
+
+  - provision client would
+    - list all inactive domains, match some name pattern (scap-*)
+    - pick one at random (and remember it into some list, so it doesn't pick it again)
+    - check custom <metadata>
+    - if the metadata indicate it's unused (no metadata or not-ours-UUID)
+      - write our UUID to the metadata
+      - re-read it (completing the mutex)
+      - leave the XML otherwise as-is, just swap out volume via vol-clone
+        - support --reflink
+
+
+KICKSTARTED INSTALLS:
+
+- somewhat similar:
+  - also use pre-created libvirt domains, but do not use images
+  - use virt-install --reinstall to retain the original domain XML, while being able
+    to reinstall it ad-hoc with a custom kickstart
+
+
+FULLY CUSTOM INSTALLS:
+
+- useful for special use cases with custom HW (emulated TPM2, etc.)
+- basically virt-install creating a new domain (ignoring any pre-defined ones)
+  - probably shouldn't be used by automation, only for one-VM-at-a-time on user request
+    - (no free memory/disk checking, no libvirt locking, etc.)

atex/provision/libvirt/__init__.py

@@ -0,0 +1,23 @@
+from .. import Provisioner as _Provisioner
+from ... import util, ssh
+
+class LibvirtProvisioner(_Provisioner):
+    number = 123
+
+    def reserve(self):
+        util.debug(f"reserving {self.number}")
+
+    # TODO: as simple attribute, to be guaranteed set when reserve() returns,
+    #       can be overriden by a getter function if you need to keep track
+    #       how many times it was accessed
+    def connection(self):
+        #return {'Hostname': '1.2.3.4', 'User': 'root', 'IdentityFile': ...}
+        util.debug(f"returning ssh for {self.number}")
+        return ssh.SSHConn({'Hostname': '1.2.3.4', 'User': 'root'})
+
+    def release(self):
+        util.debug(f"releasing {self.number}")
+
+    def alive(self):
+        util.debug(f"always alive: {self.number}")
+        return True

atex/provision/libvirt/setup-libvirt.sh

@@ -0,0 +1,72 @@
+#!/bin/bash
+
+set -xe
+
+# install RPM dependencies
+dnf --setopt=install_weak_deps=False -y install \
+    libvirt-daemon-driver-qemu \
+    libvirt-daemon-driver-storage-disk \
+    libvirt-daemon-config-network \
+    libvirt-client \
+    qemu-kvm \
+    swtpm-tools
+
+# start all sockets that were enabled by libvirt-daemon RPM scripts
+# (simulating a reboot)
+if systemctl --quiet is-enabled libvirtd.service; then
+    systemctl start libvirtd.service
+else
+    sockets=$(
+        systemctl list-unit-files --full \
+        --type=socket --state=enabled 'virt*' \
+        | grep '^virt' | sed 's/ .*//'
+    )
+    for socket in $sockets; do
+        systemctl start "$socket"
+    done
+fi
+
+tmpfile=$(mktemp)
+trap "rm -f \"$tmpfile\"" EXIT
+
+# set up a default network
+if virsh -q net-list --name | grep -q '^default *$'; then
+    virsh net-destroy default
+    virsh net-undefine default
+elif virsh -q net-list --name --inactive | grep -q '^default *$'; then
+    virsh net-undefine default
+fi
+cat > "$tmpfile" <<EOF
+<network>
+    <name>default</name>
+    <forward mode='nat'/>
+    <bridge name='virbr0' stp='off' delay='0'/>
+    <ip address='100.80.60.1' netmask='255.255.255.0'>
+        <dhcp>
+            <range start='100.80.60.2' end='100.80.60.250'/>
+        </dhcp>
+    </ip>
+</network>
+EOF
+virsh net-define "$tmpfile"
+virsh net-autostart default
+virsh net-start default
+
+# set up a default network
+if virsh -q pool-list --name | grep -q '^default *$'; then
+    virsh pool-destroy default
+    virsh pool-undefine default
+elif virsh -q pool-list --name --inactive | grep -q '^default *$'; then
+    virsh pool-undefine default
+fi
+cat > "$tmpfile" <<EOF
+<pool type='dir'>
+    <name>default</name>
+    <target>
+        <path>/var/lib/libvirt/images</path>
+    </target>
+</pool>
+EOF
+virsh pool-define "$tmpfile"
+virsh pool-autostart default
+virsh pool-start default